Manager Options

Each manager has a *ManagerOptions container and a *TermOptions class for one of its terms. You rarely build a term options object by hand: <Term>.configure(...) returns one. The container holds terms as named fields, and the name is the key other code uses (env.reward_manager, get_term("<name>"), a reward's command_name, ...). Observation and reward terms are grouped one level further (ObservationGroupOptions, RewardGroupOptions). The terms guide explains configuring terms.

from eden.options.managers.observations import ObservationGroupOptions, ObservationManagerOptions
from eden.options.managers.rewards import RewardManagerOptions

Base

ManagerTermOptions is the base of every term's options; FunctionTermOptions adds the params dict that configure(func=...) fills, for the kinds that accept function terms. ManagerOptions is the base of the containers.

Base manager-options class with dynamic per-term fields.

Attributes

T_TermOptions module-attribute

T_TermOptions = TypeVar('T_TermOptions', bound=ConfigurableOptions)

Classes

ManagerTermOptions

ManagerTermOptions(**data)

Bases: DynamicConfigurableOptions

Base for all per-term options (RewardTermOptions, EventTermOptions, ...).

Term options stay extra="allow" because class-based terms carry their per-term parameters as extras (the options class is shared by every term of the kind). Typo protection comes from validating those extras against the registered term instead:

• At construction and on attribute assignment (model_post_init / __setattr__): when name resolves in the kind's term registry — stamped onto this class as _term_registry_ by TermRegistry.__init__ — extras must be parameters of the registered term, and for function terms the params keys must be arguments of the registered function. RewardTermOptions(name="upright", wieght=2.0) and options.wieght = 2.0 both raise in the config file that contains the typo (a rejected assignment is rolled back).
• On copy-with-changes (updated(...) / model_copy(update=...)): the same check runs on the copy — pydantic's update= is otherwise unvalidated and would park {"wieght": 2.0} as an extra next to the untouched weight.
• At build (ConfigurableMixin.__init__): the pre-existing invalid-parameter check backstops options whose name was missing or not yet registered at construction time.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

name class-attribute instance-attribute

name: str | None = None

FunctionTermOptions

FunctionTermOptions(**data)

Bases: ManagerTermOptions

Term options for the function-capable kinds — the ones with a *TermFuncWrapper.

Declares the params dict that configure(func=...) fills and the wrapper's compute() forwards to the wrapped function. Kinds whose terms are class-based only (action, command, recorder, motion and the three modifier kinds) subclass :class:ManagerTermOptions directly; a new kind that grows a function wrapper should switch its options base to this class.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

params class-attribute instance-attribute

params: dict[str, Any] | None = None

ManagerOptions

ManagerOptions(**data)

Bases: DynamicConfigurableOptions, Generic[T_TermOptions]

Generic base class for manager options.

Stores term options as extra fields, validates their types via model_post_init, and provides disable_term for runtime removal.

Usage::

class EventManagerOptions(ManagerOptions[EventTermOptions]):
    pass

# Entries forming a union parametrize with `|` — accepted types stay visible
# in the class signature (e.g. reward managers accept flat terms or groups):
class RewardManagerOptions(ManagerOptions[RewardTermOptions | RewardGroupOptions]):
    pass

The term options class (or union) is automatically extracted from the generic parameter; isinstance accepts union types directly.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Methods:

term_keys

term_keys() -> tuple[str, ...]

Return only the registered ManagerTerm entry names.

These are the extras validated by :meth:model_post_init to be _term_options_class_ instances.

This is intentionally distinct from :meth:ConfigurableOptions.keys, which returns every named child of the options object — including declared model fields that are config knobs (e.g. RecorderManagerOptions.dataset_filename), not terms.

Source code in eden/options/managers/base.py

def term_keys(self) -> tuple[str, ...]:
    """Return only the registered ``ManagerTerm`` entry names.

    These are the extras validated by :meth:`model_post_init` to be
    ``_term_options_class_`` instances.

    This is intentionally distinct from :meth:`ConfigurableOptions.keys`,
    which returns every named child of the options object — including
    declared model fields that are config knobs (e.g.
    ``RecorderManagerOptions.dataset_filename``), not terms.
    """
    extra = self.__pydantic_extra__ or {}
    return tuple(key for key in extra if not key.startswith("_option_"))

disable_term

disable_term(name: str) -> None

Remove a term from this manager options by name.

Raises KeyError (listing the terms that exist) for an unknown name and RuntimeError on a locked config.

Source code in eden/options/managers/base.py

def disable_term(self, name: str) -> None:
    """Remove a term from this manager options by name.

    Raises ``KeyError`` (listing the terms that exist) for an unknown name and
    ``RuntimeError`` on a locked config.
    """
    self._remove_named_child(name, noun="term")

Functions:

Actions

Action manager and action-term configuration options.

Classes

ActionTermOptions

ActionTermOptions(**data)

Bases: ManagerTermOptions

Action term specification.

PARAMETER	DESCRIPTION
entity_name	The name of the entity to control.
dofs_name	The names of the DOFs to control.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

entity_name instance-attribute

entity_name: str

dofs_name class-attribute instance-attribute

dofs_name: str | list[str] = []

ActionManagerOptions

ActionManagerOptions(**data)

Bases: ManagerOptions[ActionTermOptions]

Action manager options.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Observations

Observation manager, group, and term configuration options.

Attributes

Classes

ObservationTermOptions

ObservationTermOptions(**data)

Bases: FunctionTermOptions

Observation term specification.

The manager processes each frame of the term's output in this order: modifiers, noise, clip, scale, then the group's nan_policy, and last the history window.

PARAMETER	DESCRIPTION
modifiers	Transforms applied to the term's output in list order, before noise (default=[], none). Each entry is a registered :class:~eden.managers.modifiers.base.ObservationModifier configured with <ModifierClass>.configure(...), e.g. ExponentialMovingAverage.configure(alpha=0.2) or ObservationDelay.configure(control_steps=2). Unlike noise, modifiers run in every mode: training, eval and deployment. A modifier must return the shape, dtype and device it receives.
noise	Noise model applied to the observation, in training only (default=None, no noise).
clip	Range to clip the observation values (default=None, no clipping).
scale	Scaling factor applied to the observation (default=1.0). A list gives a per-component scale matched against the term's feature dim — the last dimension of its raw compute() output — validated at env-construction time and applied before history stacking.
history_length	Number of previous observations to include (default=0, no history).
flatten_history_dim	Whether to flatten the history into the feature axis, giving (num_envs, history_length * dim) instead of (num_envs, history_length, dim) (default=True, the same as the group's).
backfill	Whether to backfill the history with the first observation (default=True). If False, the history will be filled with zeros.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

modifiers class-attribute instance-attribute

modifiers: list[ObservationModifierOptions] = []

noise class-attribute instance-attribute

noise: NoiseOptions | None = None

clip class-attribute instance-attribute

clip: Vec2FType | None = None

scale class-attribute instance-attribute

scale: float | list[float] = 1.0

history_length class-attribute instance-attribute

history_length: int = 0

flatten_history_dim class-attribute instance-attribute

flatten_history_dim: bool = True

backfill class-attribute instance-attribute

backfill: bool = True

POST_COMPUTE_FIELDS class-attribute

POST_COMPUTE_FIELDS: frozenset[str] = frozenset({'modifiers', 'noise', 'clip', 'scale', 'history_length', 'flatten_history_dim', 'backfill'})

ObservationGroupOptions

ObservationGroupOptions(**data)

Bases: DynamicConfigurableOptions

Observation group options.

PARAMETER	DESCRIPTION
concatenate_terms	Whether to concatenate the terms (default=True).
concatenate_dim	The dimension to concatenate the terms (default=-1).
terms_order	The order of the terms in the group (default=None).
enable_corruption	Whether to allow adding noise to each term in the group (default=True). False is a group-level master switch: it disables the noise of every term in the group, whatever each term configured, so one term dict can serve a noisy policy and a clean critic. The terms keep their noise in the config — the group does not edit what it adopts — and the observation manager drops it when it builds the group, logging one info line that names the group and the terms, so noise that does not reach the policy is stated rather than silent.
history_length	The history length enforced for all terms in the group (default=None).
flatten_history_dim	Whether to flatten the history dimension (default=True).
backfill	Whether to backfill the history with the first observation (default=True). If False, the history will be filled with zeros.
nan_policy	What to do when a term delivers a non-finite value (NaN or ±Inf) (default="disabled", no check). The check is on each term's frame after its modifiers, noise, clip and scale, just before the history window, so a report names the term. A clip that bounds an infinity is therefore never reported. "sanitize" replaces each non-finite entry with 0.0 in what the policy receives. "warn" does the same and also logs the first occurrence for each term, naming the envs. "error" raises FloatingPointError. The check runs in every mode (training, eval, deployment) and on every computation, including the final-observation snapshot. It cannot clean a stateful modifier upstream of it: a NaN that reaches an ExponentialMovingAverage stays in the average until the env resets. "sanitize" stays on the device. "error", and "warn" for terms that have not warned yet, cost one GPU sync per group per observation compute.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

concatenate_terms class-attribute instance-attribute

concatenate_terms: bool = True

concatenate_dim class-attribute instance-attribute

concatenate_dim: int = -1

terms_order class-attribute instance-attribute

terms_order: list[str] | None = None

enable_corruption class-attribute instance-attribute

enable_corruption: bool = True

history_length class-attribute instance-attribute

history_length: int | None = None

flatten_history_dim class-attribute instance-attribute

flatten_history_dim: bool = True

backfill class-attribute instance-attribute

backfill: bool = True

nan_policy class-attribute instance-attribute

nan_policy: Literal['disabled', 'warn', 'sanitize', 'error'] = 'disabled'

terms instance-attribute

terms: dict[str, ObservationTermOptions]

Methods:

term_keys

term_keys() -> tuple[str, ...]

Return the names of this group's terms (the counterpart of ManagerOptions.term_keys).

Source code in eden/options/managers/observations.py

def term_keys(self) -> tuple[str, ...]:
    """Return the names of this group's terms (the counterpart of ``ManagerOptions.term_keys``)."""
    return tuple(self._term_entries())

disable_term

disable_term(name: str) -> None

Remove a term from this group by name, and from terms_order when the group declares one.

terms_order must list exactly the group's terms, so a name left behind there would fail the next load or the observation manager's build, far from this call.

Raises KeyError (listing the terms that exist) for an unknown name and RuntimeError on a locked config.

Source code in eden/options/managers/observations.py

def disable_term(self, name: str) -> None:
    """Remove a term from this group by name, and from ``terms_order`` when the group declares one.

    ``terms_order`` must list exactly the group's terms, so a name left behind there would fail
    the next load or the observation manager's build, far from this call.

    Raises ``KeyError`` (listing the terms that exist) for an unknown name and
    ``RuntimeError`` on a locked config.
    """
    self._remove_named_child(name, noun="term")
    if self.terms_order is not None:
        # Rebuilt, not edited in place: assignment on an options model is unvalidated, so the
        # list may be shared with another group or with the code that assigned it.
        self.terms_order = [term for term in self.terms_order if term != name]

ObservationManagerOptions

ObservationManagerOptions(**data)

Bases: ManagerOptions[ObservationGroupOptions]

Observation manager options.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Rewards

Reward manager, group, and reward-term configuration options.

Classes

RewardTermOptions

RewardTermOptions(**data)

Bases: FunctionTermOptions

Reward term specification.

PARAMETER	DESCRIPTION
range_s	The time window(s) in seconds where the reward is active, as (start_s, end_s) or a list of such tuples. Both ends are inclusive. If None, the reward is active for the entire episode. Default is None.
weight	A reward weight for the term. Default is 1.0.
tags	Optional labels for grouping reward terms (e.g. ["penalty"] or ["tracking", "feet"]). Curricula and other consumers can filter terms by tag instead of hard-coding term names.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

range_s class-attribute instance-attribute

range_s: tuple[float, float] | list[tuple[float, float]] | None = None

weight class-attribute instance-attribute

weight: float = 1.0

tags class-attribute instance-attribute

tags: list[str] = []

RewardGroupOptions

RewardGroupOptions(**data)

Bases: ManagerOptions[RewardTermOptions]

A named group of reward terms.

Groups give downstream consumers a per-group reward readout (multi-channel critics, CMDP task/style/penalty splits, per-group logging) without changing the scalar reward the environment returns — the reward manager always sums over all groups. Unlike observation groups, reward groups partition one flat term set: active term names must be unique across the whole reward manager, groups included.

Extras type-checking, term_keys(), and disable_term() all come from :class:ManagerOptions via the generic parameter.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

RewardManagerOptions

RewardManagerOptions(**data)

Bases: ManagerOptions[RewardTermOptions | RewardGroupOptions]

Reward manager options.

Entries are flat reward terms, named groups of reward terms, or a mix of both. Flat terms implicitly belong to the manager's default group.

PARAMETER

DESCRIPTION

log_per_term_rewards

Whether reset() emits the per-term reward log keys (Episode_Reward/<term> and the diagnostic Episode_Reward_Raw/<term>) each iteration, which dominate per-iteration log volume on term-heavy configs. None (default) auto-selects: off when the config declares explicit reward groups — the Episode_Reward_Group/<group> sums are the intended readout — and on otherwise, since a fully-flat config has no group readout to fall back to. Set True to always emit per-term keys or False to always suppress them. Group-sum keys are always emitted when groups are declared and are unaffected by this flag; it changes only logging, never the reward itself.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

log_per_term_rewards class-attribute instance-attribute

log_per_term_rewards: bool | None = None

Methods:

disable_term

disable_term(name: str) -> None

Remove a flat term, a whole group, or a term nested inside exactly one group, by name.

The name must resolve unambiguously. If it matches more than one entry (a term declared in several groups, or a top-level entry and a nested term), this raises ValueError — disable through the owning group instead: getattr(options, group).disable_term(name). Ambiguity here is name-based, not activity-based: a weight-0 (inert) duplicate still counts as a match, unlike the manager's build-time uniqueness check, because options can't know final weights.

Source code in eden/options/managers/rewards.py

def disable_term(self, name: str) -> None:
    """Remove a flat term, a whole group, or a term nested inside exactly one group, by name.

    The name must resolve unambiguously. If it matches more than one entry (a term
    declared in several groups, or a top-level entry and a nested term), this raises
    ``ValueError`` — disable through the owning group instead:
    ``getattr(options, group).disable_term(name)``. Ambiguity here is name-based, not
    activity-based: a weight-0 (inert) duplicate still counts as a match, unlike the
    manager's build-time uniqueness check, because options can't know final weights.
    """
    owner_groups = self._groups_containing(name)
    places = (["top level"] if name in self.term_keys() else []) + [f"group '{g}'" for g in owner_groups]
    if len(places) > 1:
        raise ValueError(
            f"Name '{name}' is ambiguous ({' and '.join(places)}). To remove a nested term, call "
            f"disable_term on its group: getattr(options, group).disable_term({name!r})."
        )
    if owner_groups:
        getattr(self, owner_groups[0]).disable_term(name)
        return
    # Top-level hit (flat term or whole group), or the canonical KeyError.
    self._remove_named_child(name, noun="term")

Terminations

Termination manager and termination-term configuration options.

Classes

TerminationTermOptions

TerminationTermOptions(**data)

Bases: FunctionTermOptions

Termination term specification.

PARAMETER	DESCRIPTION
time_out	Whether the term contributes towards episodic timeouts. Defaults to False.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

time_out class-attribute instance-attribute

time_out: bool = False

TerminationManagerOptions

TerminationManagerOptions(**data)

Bases: ManagerOptions[TerminationTermOptions]

Termination manager options.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Commands

Command manager and command-term configuration options.

Classes

CommandTermOptions

CommandTermOptions(**data)

Bases: ManagerTermOptions

Command term specification.

PARAMETER	DESCRIPTION
resampling_time_range	The (min, max) time before a command is resampled [s]. Default is None.
debug_vis	Whether to visualize debug information. Defaults to False.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

resampling_time_range class-attribute instance-attribute

resampling_time_range: tuple[float, float] | None = None

debug_vis class-attribute instance-attribute

debug_vis: bool = False

CommandManagerOptions

CommandManagerOptions(**data)

Bases: ManagerOptions[CommandTermOptions]

Command manager options.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Events

Event manager and event-term configuration options.

Classes

EventTermOptions

EventTermOptions(**data)

Bases: FunctionTermOptions

Event term specification.

PARAMETER	DESCRIPTION
mode	The mode of the event term. Accepts either an EventMode member or its string value (e.g. "reset").
interval_range_s	(min, max) of the time between firings in seconds, resampled uniformly after each firing. Required when mode is "interval".
is_global_time	Interval mode only: one countdown shared by all envs (the term fires with no envs_idx) instead of one countdown per env.
min_step_count_between_reset	Reset mode only: the minimum number of global env steps since the term last fired on an env before a reset fires it on that env again. 0 fires it on every reset.
priority	Lower numbers run first within the same mode. Default is 0.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

mode class-attribute instance-attribute

mode: EventMode = EventMode.RESET

interval_range_s class-attribute instance-attribute

interval_range_s: tuple[float, float] | None = None

is_global_time class-attribute instance-attribute

is_global_time: bool = False

min_step_count_between_reset class-attribute instance-attribute

min_step_count_between_reset: int = 0

priority class-attribute instance-attribute

priority: int = 0

EventManagerOptions

EventManagerOptions(**data)

Bases: ManagerOptions[EventTermOptions]

Event manager options.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Curricula

Curriculum manager and curriculum-term configuration options.

Classes

CurriculumTermOptions

CurriculumTermOptions(**data)

Bases: FunctionTermOptions

Curriculum term specification.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

CurriculumManagerOptions

CurriculumManagerOptions(**data)

Bases: ManagerOptions[CurriculumTermOptions]

Curriculum manager options.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Metrics

Metric manager and metric-term configuration options.

Classes

MetricTermOptions

MetricTermOptions(**data)

Bases: FunctionTermOptions

Metric term specification.

PARAMETER	DESCRIPTION
success_threshold	The threshold for success. The threshold is inclusive. Defaults to 1.0.
direction	The metric direction. Accepts either a MetricDirection member or its string value (e.g. "hib"). Defaults to "hib".
metric_mode	The metric success mode. Accepts either a MetricMode member or its string value. Defaults to "interval".
is_cumulative	Whether the metric is cumulative. Defaults to False.
contributes_to_success	Whether the term participates in task-success accounting (Metrics/Success / Metrics/Progress and the recorder's per-episode success label). Defaults to True; set False for a shared-quantity term with no success notion — see :class:~eden.managers.metric_manager.MetricTerm.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

success_threshold class-attribute instance-attribute

success_threshold: float = 1.0

direction class-attribute instance-attribute

direction: MetricDirection = MetricDirection.HIB

metric_mode class-attribute instance-attribute

metric_mode: MetricMode = MetricMode.INTERVAL

is_cumulative class-attribute instance-attribute

is_cumulative: bool = False

contributes_to_success class-attribute instance-attribute

contributes_to_success: bool = True

PhaseOptions

PhaseOptions(**data)

Bases: ConfigurableOptions

Configuration for a single phase in SequentialMetricTerm.

PARAMETER	DESCRIPTION
term	Inline term configuration (from .configure()). Mutually exclusive with ref. TYPE: MetricTermOptions
ref	Reference to a sibling term in MetricManagerOptions. Mutually exclusive with term. TYPE: str
name	Phase display name. Auto-derived from the term if empty. TYPE: str
threshold	Phase advancement threshold. Defaults to 1.0. TYPE: float
hold	If True, reuse the phase predicate as hold condition. TYPE: bool
hold_term	Separate hold predicate (overrides hold). TYPE: MetricTermOptions
hold_until	Scoped hold expiration — a phase name or index. TYPE: str or int
hold_guard	Name of another phase whose hold must also be failing for this hold to be enforced. If the guard phase's hold is still passing, this hold is suppressed. For example, hold_guard="grasp" on a lift hold means: "only revert for lift failure if the robot also lost its grasp — lowering while grasping is intentional." TYPE: str

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

term class-attribute instance-attribute

term: MetricTermOptions | None = None

ref class-attribute instance-attribute

ref: str | None = None

name class-attribute instance-attribute

name: str = ''

threshold class-attribute instance-attribute

threshold: float = 1.0

hold class-attribute instance-attribute

hold: bool = False

hold_term class-attribute instance-attribute

hold_term: MetricTermOptions | None = None

hold_until class-attribute instance-attribute

hold_until: str | int | None = None

hold_guard class-attribute instance-attribute

hold_guard: str | None = None

CriterionOptions

CriterionOptions(**data)

Bases: ConfigurableOptions

One criterion of a :class:~eden.managers.terms.metrics.sequence.RubricMetricTerm.

PARAMETER	DESCRIPTION
name	The criterion's name, which the after lists of later criteria refer to. TYPE: str
term	The predicate (from .configure()); the criterion is met in a step where the term succeeds, as its direction and success_threshold say. TYPE: MetricTermOptions
after	Earlier criteria that must have been reached, in this step or before, for this one to count. TYPE: list[str]

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

name instance-attribute

name: str

term instance-attribute

term: MetricTermOptions

after class-attribute instance-attribute

after: list[str] = []

MetricManagerOptions

MetricManagerOptions(**data)

Bases: ManagerOptions[MetricTermOptions]

Metric manager options.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Recorders

Recorder manager and recorder-term configuration options.

Classes

RecorderTermOptions

RecorderTermOptions(**data)

Bases: ManagerTermOptions

Recorder term specification.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

RecorderManagerOptions

RecorderManagerOptions(**data)

Bases: ManagerOptions[RecorderTermOptions]

Recorder manager options.

PARAMETER	DESCRIPTION
file_handler_options	The options for the file handler.
dataset_export_dir_path	The directory path where the recorded datasets are exported.
dataset_filename	Dataset file name without file extension.
dataset_export_mode	The mode to handle episode exports.
override	Whether to overwrite an existing dataset file. False (default) appends to it.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

file_handler_options class-attribute instance-attribute

file_handler_options: FileHandlerOptions = Field(default_factory=_default_file_handler_options)

dataset_export_dir_path class-attribute instance-attribute

dataset_export_dir_path: str = os.path.join(tempfile.gettempdir(), 'eden', 'logs')

dataset_filename class-attribute instance-attribute

dataset_filename: str = 'dataset'

dataset_export_mode class-attribute instance-attribute

dataset_export_mode: DatasetExportMode = DatasetExportMode.EXPORT_ALL

override class-attribute instance-attribute

override: bool = False

Motions

Motion manager and motion-term configuration options.

Classes

MotionGroupOptions

MotionGroupOptions(**data)

Bases: ConfigurableOptions

Restrict each env to the clips that match the variant of a heterogeneous entity it holds.

A heterogeneous entity (GroupedEntityOptions) gives each env one variant for the whole run — one object mesh out of a bank. A reference clip that manipulates object A is meaningless in an env holding object B, so with this set every motion draw (initial assignment, reset, adaptive start bins) samples only among the clips whose per-clip label equals the env's variant label.

PARAMETER	DESCRIPTION
entity_name	The heterogeneous scene entity whose per-env variant selects the group, e.g. "object". TYPE: str
metadata_key	The dataset's per-clip label list the groups are matched against (dataset.motion_labels(metadata_key)), e.g. "objects". Defaults to "objects". TYPE: str
variant_labels	One label per variant, in the entity's grouped_entities order: variant_labels[i] is the per-clip label of the clips an env holding variant i may play. Derive it from the same ordered constant that builds grouped_entities so the two cannot drift. Labels may repeat (variants then share a group). TYPE: list[str]

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

entity_name instance-attribute

entity_name: str

metadata_key class-attribute instance-attribute

metadata_key: str = 'objects'

variant_labels instance-attribute

variant_labels: list[str]

MotionTermOptions

MotionTermOptions(**data)

Bases: ManagerTermOptions

Configuration for the motion buffer.

PARAMETER	DESCRIPTION
dataset_options	The options for the dataset.
entities_map	Maps each environment entity name (key) to its motion sequence key in the dataset (value).
target_dofs_name	Per entity, the names of the degrees of freedom to target. The reference's DOF columns follow this list's order, which need not match the dataset's.
target_links_name	Per entity, the names of the links to target. The reference's link rows follow this list's order, which need not match the dataset's.
env_starting_stub_sampling_strategy	How a motion and its start time are drawn. "independent" (default) draws the motion, then its start time. "concat_motion_bins" draws one motion_bin_length_s bin from all motions' bins concatenated (so a longer motion is proportionally likelier) and starts inside it; requires motion_bin_length_s.
motion_start_from_middle_range	(min, max) fractions of the clip duration the start time is drawn uniformly from. Used only when max > 0 and motion_bin_length_s is None (bin sampling takes priority). Defaults to (0.0, 0.0): every clip starts at its first frame.
motion_bin_length_s	Width [s] of the start-time bins. Setting it enables bin-weighted start sampling; required by adaptive_sampling and "concat_motion_bins". Defaults to None.
adaptive_sampling	Master toggle for adaptive start-time (intra-motion bin) sampling. Defaults to False.
adaptive_kernel_size	Temporal smoothing kernel width K. Smooths each failure onto the bin it died in and the K - 1 bins before it, so starts move onto the run-up to a hard moment (BeyondMimic's look-ahead kernel). 1 disables smoothing. Defaults to 1.
adaptive_lambda	Exponential decay for kernel weights: the death bin weighs 1, the bin i before it adaptive_lambda ** i, normalised to sum to 1. Defaults to 0.8.
adaptive_uniform_ratio	Minimum uniform floor in sampling probabilities. Defaults to 0.1.
adaptive_alpha	EMA blend rate for failure counts. Defaults to 0.001.
adaptive_failure_rate_max_over_mean	Per-START-bin concentration clamp for adaptive start-time sampling. A bin whose (smoothed) failure rate exceeds mean * this (per-motion mean over its bins) is clipped to that ceiling before normalization, so no single bin can absorb arbitrarily much probability mass even if its failure rate is pathologically high (e.g. a momentarily impossible frame). Bin-level analogue of motion_weight_failure_rate_max_over_mean; without it the uniform mix alone only bounds the floor, not the peak, so the start distribution can still collapse onto one bin. <= 0 disables the clamp. Defaults to 10.0.
motion_weights	Initial per-motion-id sampling weights, one entry per loaded trajectory in motion-id order. None (default) weights every motion equally. A list[float] supplies the weights inline; a str is a path to a text/JSON file (loaded via load_text) holding a "motion_weights" key with that list — convenient for large clip libraries. The length must equal the number of loaded trajectories or build raises. When adaptive_motion_weights is True these are the starting weights the curriculum then rewrites.
adaptive_motion_weights	Master toggle for adaptive per-motion-id sampling (hard-motion mining). Orthogonal to adaptive_sampling (which controls intra-motion start-time bins). When True, _motion_weights is updated each training iteration based on per-motion success / early-termination outcomes during rollouts. Defaults to False.
motion_weight_success_discount	Per-success multiplicative decay applied to a motion's weight when its motion plays to its natural end (regardless of whether the env also terminated this step). < 1.0 shrinks the weight of easy motions; = 1.0 disables decay. Defaults to 0.999 (matches ProtoMotions reference).
motion_weight_failure_amplify	Per-failure multiplicative gain applied to a motion's weight when an episode terminates early without the motion completing. > 1.0 boosts the weight of hard motions; = 1.0 disables amplification. Defaults to 2.0 (matches ProtoMotions reference). For a gentler, symmetric per-iter pressure, set this to a value just above 1 (e.g. 1.001) alongside motion_weight_success_discount=0.999.
motion_weight_floor	Lower clamp on per-motion weight (before re-normalization), so no motion can be permanently zeroed out. Defaults to 1e-3. Only consulted by motion_weight_update_mode="compound"; the snapshot mode bounds weights via motion_weight_failure_rate_max_over_mean + motion_weight_uniform_mix instead.
motion_weight_update_mode	How _motion_weights is rewritten from the drained outcome counts: "snapshot" (default): stateless rate-proportional formulation ported from SONIC's update_adaptive_sampling_probabilities (motion_lib_base.py:2570-2585). Computes failure_rate = n_failure / (n_success + n_failure), clamps outliers at mean_failure_rate * failure_rate_max_over_mean, normalises, then blends with uniform via uniform_mix. The result is always the same function of the current drained counts — no history compounds. success_discount / failure_amplify / floor are ignored under this mode. "compound" (opt-in): log-space additive update log_w += n_success * log(success_discount) + n_failure * log(failure_amplify). Integrates all historical outcomes forever; any persistent failure-rate bias compounds exponentially until a motion saturates at the floor or at 1.0. Observed to collapse to a single motion at LAFAN1 scale; kept only for ablation runs.
motion_weight_uniform_mix	Applied AFTER the curriculum update under either mode: w := (1 - α) * w + α / N. Caps maximum concentration at (1 - α) + α/N and floors minimum at α/N, independent of the update mode's own dynamics. Defaults to 0.0 (off).
motion_weight_failure_rate_max_over_mean	Snapshot-mode-only outlier clamp. A motion with failure rate greater than mean * this is clipped to that ceiling before being converted to a probability. With N=12 and clamp=200, the worst case is one motion captures up to ~95% of the pre-mix probability mass; combined with uniform_mix=0.1 the worst-case cap becomes ~85%. Defaults to 200.0 (matches SONIC's adp_samp_failure_rate_max_over_mean).
motion_weight_update_every_n_iters	Apply the curriculum update every N PPO iterations. Outcomes accumulate in between. Defaults to 1.
log_per_motion_metrics	Emit per-motion-id distributions as wandb.Histogram panels under MotionPerMotion/Weights (current sampling weights) and MotionPerMotion/Outcome/{success_count, failure_count, total, success_rate} (per-drain counts). One histogram per metric per iter — independent of motion count. Useful for diagnosing curriculum collapse: a long tail forming in the weight distribution shows up immediately as a skewed histogram. One scalar series per motion-id would be ~47k series per iteration at AMASS scale (~9.4k motions × 5 fields), which overwhelms the wandb backend and slows rsl-rl's logger; histograms keep the diagnostic at constant cost. MotionWeights/argmax_motion_id (a single int) stays on the aggregate panel and is always emitted — that's the cheapest way to identify the dominant clip and works at any scale. Defaults to False.
log_motion_id_to_filename	When True, additionally emit MotionWeights/argmax_motion_filename as a wandb string field — the basename of the dataset file corresponding to the current argmax motion-id. Resolved against the dataset's all_motion_files list (the post-select_trajectories per-rank slice), so DDP-sharded runs may emit "<not_local>" when the argmax is held by another rank. Off by default because the integer argmax_motion_id is enough to identify the clip via the dataset's saved file order, and the string field is heavier to handle (wandb plot-by-string is awkward; mostly useful in the wandb run table for at-a-glance correlation with the integer time series).
start_at_timestep_zero_prob	On reset, with this probability force the start time to 0 instead of sampling via motion_start_from_middle_range / bin-weighted sampling. Useful for eval-mode determinism and curriculum warm-ups where every clip should begin at frame 0. Defaults to 0.0.
freeze_at_timestep_zero_prob	Per-step probability that MotionManager.compute(dt) does NOT advance _timestamp for envs currently at timestamp 0. Re-rolled every step (mirrors Holosoma's WBT semantic), so a setting of 0.5 gives an env at t=0 a 50% chance of advancing each step — useful for mild start-time jitter, NOT for permanent freeze (an env frozen on step N can advance on step N+1). Defaults to 0.0.
compute_per_motion_metrics	When True, accumulate per-step tracking error against the reference (MPJPE in world frame, root position L2 error, root quaternion geodesic error) into per-env running sums, then scatter to per-motion-id aggregators at episode reset. Drained alongside the success/failure curriculum counts (same all_reduce_fn across DDP ranks; same cadence as motion_weight_update_every_n_iters). Aggregate scalars (Mimic/mpjpe_{mean,p50,p95} etc.) flow into extras["log"]; per-motion tensors are available via summarize_per_motion_metrics() for CSV dump. Hot-path cost when enabled: one extra get_links_pos per step + 3 per-env reductions + 3 in-place adds. No CPU↔GPU sync. When disabled (default), buffers are unallocated and the accumulator is a single early-return check. Defaults to False.
metric_anchor_link_name	Optional anchor link (e.g. "torso_link"). When set together with compute_per_motion_metrics=True, additionally accumulates G-MPJPE — link MPJPE measured in the anchor frame (subtract the anchor link's world-frame position from all tracked link positions before the L2 norm). Surfaces Mimic/g_mpjpe_* scalars in extras["log"]. None → don't compute G-MPJPE, keep the baseline 3-metric set (MPJPE, root_pos_err, root_quat_err) only. Adds one extra entity find_named_links_idx_local lookup at first compute, then one get_links_pos row (for the anchor) and one subtract on the hot path. Defaults to None.
env_motion_groups	Per-env clip groups keyed on a heterogeneous entity's variant (see :class:MotionGroupOptions), for a reference that is only valid with one variant of that entity — an object-manipulation clip and the object it manipulates. None (the default) samples every env from the whole library.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

dataset_options class-attribute instance-attribute

dataset_options: DatasetOptions | None = None

entities_map class-attribute instance-attribute

entities_map: dict[str, str] = {}

target_dofs_name class-attribute instance-attribute

target_dofs_name: dict[str, str | list[str]] = {}

target_links_name class-attribute instance-attribute

target_links_name: dict[str, str | list[str]] = {}

motion_weights class-attribute instance-attribute

motion_weights: str | list[float] | None = None

env_starting_stub_sampling_strategy class-attribute instance-attribute

env_starting_stub_sampling_strategy: Literal['independent', 'concat_motion_bins'] = 'independent'

motion_start_from_middle_range class-attribute instance-attribute

motion_start_from_middle_range: tuple[float, float] | list[float] = (0.0, 0.0)

motion_bin_length_s class-attribute instance-attribute

motion_bin_length_s: float | None = None

adaptive_sampling class-attribute instance-attribute

adaptive_sampling: bool = False

adaptive_kernel_size class-attribute instance-attribute

adaptive_kernel_size: int = 1

adaptive_lambda class-attribute instance-attribute

adaptive_lambda: float = 0.8

adaptive_uniform_ratio class-attribute instance-attribute

adaptive_uniform_ratio: float = 0.1

adaptive_alpha class-attribute instance-attribute

adaptive_alpha: float = 0.001

adaptive_failure_rate_max_over_mean class-attribute instance-attribute

adaptive_failure_rate_max_over_mean: float = 10.0

adaptive_motion_weights class-attribute instance-attribute

adaptive_motion_weights: bool = False

motion_weight_success_discount class-attribute instance-attribute

motion_weight_success_discount: float = 0.999

motion_weight_failure_amplify class-attribute instance-attribute

motion_weight_failure_amplify: float = 2.0

motion_weight_floor class-attribute instance-attribute

motion_weight_floor: float = 0.001

motion_weight_update_mode class-attribute instance-attribute

motion_weight_update_mode: Literal['compound', 'snapshot'] = 'snapshot'

motion_weight_uniform_mix class-attribute instance-attribute

motion_weight_uniform_mix: float = 0.0

motion_weight_failure_rate_max_over_mean class-attribute instance-attribute

motion_weight_failure_rate_max_over_mean: float = 200.0

motion_weight_update_every_n_iters class-attribute instance-attribute

motion_weight_update_every_n_iters: int = 1

start_at_timestep_zero_prob class-attribute instance-attribute

start_at_timestep_zero_prob: float = 0.0

freeze_at_timestep_zero_prob class-attribute instance-attribute

freeze_at_timestep_zero_prob: float = 0.0

compute_per_motion_metrics class-attribute instance-attribute

compute_per_motion_metrics: bool = False

metric_anchor_link_name class-attribute instance-attribute

metric_anchor_link_name: str | None = None

log_per_motion_metrics class-attribute instance-attribute

log_per_motion_metrics: bool = False

log_motion_id_to_filename class-attribute instance-attribute

log_motion_id_to_filename: bool = False

env_motion_groups class-attribute instance-attribute

env_motion_groups: MotionGroupOptions | None = None

MotionManagerOptions

MotionManagerOptions(**data)

Bases: ManagerOptions[MotionTermOptions]

Configuration for the motion reference manager.

PARAMETER	DESCRIPTION
entities_map	Not read by the motion manager; each term's own entities_map maps entities to sequences.
num_frames	The number of future reference frames generated per step. Defaults to 1.
data_start_from	Where the 0-th reference frame sits: "one_frame_interval" (default) puts it one frame interval after the current time t, "current_time" at t.
frame_interval_s_range	(min, max) time between reference frames [s], sampled uniformly per env on reset. Defaults to (0.1, 0.1).
mp_split_method	How the motion library is split across DDP ranks: "None" (default) gives every rank all of it, "Even" splits it evenly (round-robin), "Segment" assigns each rank a contiguous segment.
symmetric_augmentation	Whether to enable symmetric augmentation of motion data (mirroring across the x-z plane). When True, the required mapping fields below must also be provided.
symmetric_augmentation_joint_mapping	The joint index permutation for symmetric augmentation. Maps each joint to its mirrored counterpart.
symmetric_augmentation_joint_reverse_buf	Per-joint sign multipliers for symmetric augmentation (e.g., -1.0 for joints that flip sign when mirrored). Required when symmetric_augmentation is True.
symmetric_augmentation_links_mapping	Link index permutation for symmetric augmentation (in the order of links_of_interests). Required when symmetric_augmentation is True and links are referenced.
reference_prim_path	Not read by the motion manager.
resync_on_motion_end	When True, an env whose reference reaches the end of its clip is soft-reset mid-episode: a fresh start phase is resampled and the robot is teleported onto the new reference start (via the ReferenceStateInitialization event term), WITHOUT ending the episode. Mirrors the clip-wrap behavior of MotionCommand (used by the beyondmimic example). Default False: the reference freezes at the last frame (velocities zeroed) and the robot is not re-synced.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

entities_map class-attribute instance-attribute

entities_map: dict[str, str] = {}

num_frames class-attribute instance-attribute

num_frames: int = 1

data_start_from class-attribute instance-attribute

data_start_from: Literal['one_frame_interval', 'current_time'] = 'one_frame_interval'

frame_interval_s_range class-attribute instance-attribute

frame_interval_s_range: tuple[float, float] = (0.1, 0.1)

mp_split_method class-attribute instance-attribute

mp_split_method: Literal['None', 'Even', 'Segment'] = 'None'

symmetric_augmentation class-attribute instance-attribute

symmetric_augmentation: bool = False

symmetric_augmentation_joint_mapping class-attribute instance-attribute

symmetric_augmentation_joint_mapping: Sequence[int] | None = None

symmetric_augmentation_joint_reverse_buf class-attribute instance-attribute

symmetric_augmentation_joint_reverse_buf: Sequence | None = None

symmetric_augmentation_links_mapping class-attribute instance-attribute

symmetric_augmentation_links_mapping: Sequence[int] | None = None

reference_prim_path class-attribute instance-attribute

reference_prim_path: str | None = None

resync_on_motion_end class-attribute instance-attribute

resync_on_motion_end: bool = False

Methods:

adaptive_motion_terms

adaptive_motion_terms() -> list[str]

The motion terms that mine hard motions (adaptive_motion_weights), whose weights a curriculum steps.

Source code in eden/options/managers/motions.py

def adaptive_motion_terms(self) -> list[str]:
    """The motion terms that mine hard motions (``adaptive_motion_weights``), whose weights a curriculum steps."""
    return [name for name in self.term_keys() if getattr(self, name).adaptive_motion_weights]

Modifiers

Options for action modifiers, observation modifiers and noise models.

Configuration options for action/observation modifiers (including noise).

Classes

NoiseOptions

NoiseOptions(**data)

Bases: ManagerTermOptions

Noise options.

PARAMETER	DESCRIPTION
operation	The operation to apply to the noise. Default is NoiseOperation.ADD.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

operation class-attribute instance-attribute

operation: NoiseOperation = NoiseOperation.ADD

ActionModifierOptions

ActionModifierOptions(**data)

Bases: ManagerTermOptions

Options for action modifiers.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

ObservationModifierOptions

ObservationModifierOptions(**data)

Bases: ManagerTermOptions

Options for an observation modifier — one entry of an observation term's modifiers list.

Built by <ModifierClass>.configure(...); the modifier's own parameters ride as extras, validated against the registered class like any term's.

Source code in eden/options/options.py

def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

See also

• Terms guide
• Managers
• Built-in terms