isaaclab_experimental.managers

isaaclab_experimental.managers#

Experimental manager implementations.

This package is intended for experimental forks of manager implementations while keeping stable task configs and the stable isaaclab.managers package intact.

Symbols are lazily resolved from the __init__.pyi stub so that importing this package (e.g. to access pure-data cfg types like ObservationTermCfg) does not eagerly pull in runtime managers that depend on a running simulator. This mirrors the stable isaaclab.managers package.

Additional Public Classes#

The following classes are part of the public isaaclab_experimental.managers API.

`ActionManager`	Manager for processing and applying actions for a given world.
`ActionTerm`	Base class for action terms.
`CommandManager`	Manager for generating commands.
`CommandTerm`	The base class for implementing a command term.
`EventManager`	Manager for orchestrating operations based on different simulation events (Warp-first for interval/reset).
`ManagerBase`	Base class for all managers.
`ManagerTermBase`	Base class for manager terms.
`ObservationManager`	Manager for computing observation signals for a given world.
`RewardManager`	Manager for computing reward signals for a given world.
`SceneEntityCfg`	Scene entity configuration with an optional Warp joint mask.
`TerminationManager`	Manager for computing done signals for a given world (Warp-first).

class isaaclab_experimental.managers.ActionManager[source]#

Bases: ManagerBase

Manager for processing and applying actions for a given world.

The action manager handles the interpretation and application of user-defined actions on a given world. It is comprised of different action terms that decide the dimension of the expected actions.

The action manager performs operations at two stages:

processing of actions: It splits the input actions to each term and performs any pre-processing needed. This should be called once at every environment step.
apply actions: This operation typically sets the processed actions into the assets in the scene (such as robots). It should be called before every simulation step.

Methods:

`__init__`(cfg, env)	Initialize the action manager.
`__new__`(args, *kwargs)

__init__(cfg: object, env: ManagerBasedEnv)[source]#

Initialize the action manager.

Parameters:

cfg¶ – The configuration object or dictionary (dict[str, ActionTermCfg]).
env¶ – The environment instance.

Raises:

ValueError – If the configuration is None.

classmethod __new__(*args, **kwargs)#

class isaaclab_experimental.managers.ActionTerm[source]#

Bases: ManagerTermBase

Base class for action terms.

The action term is responsible for processing the raw actions sent to the environment and applying them to the asset managed by the term. The action term is comprised of two operations:

Processing of actions: This operation is performed once per environment step and is responsible for pre-processing the raw actions sent to the environment.
Applying actions: This operation is performed once per simulation step and is responsible for applying the processed actions to the asset managed by the term.

Methods:

`__init__`(cfg, env)	Initialize the action term.
`__new__`(args, *kwargs)

__init__(cfg: ActionTermCfg, env: ManagerBasedEnv)[source]#

Initialize the action term.

Parameters:

cfg¶ – The configuration object.
env¶ – The environment instance.

classmethod __new__(*args, **kwargs)#

class isaaclab_experimental.managers.CommandManager[source]#

Bases: ManagerBase

Manager for generating commands.

The command manager is used to generate commands for an agent to execute. It makes it convenient to switch between different command generation strategies within the same environment. For instance, in an environment consisting of a quadrupedal robot, the command to it could be a velocity command or position command. By keeping the command generation logic separate from the environment, it is easy to switch between different command generation strategies.

The command terms are implemented as classes that inherit from the CommandTerm class. Each command generator term should also have a corresponding configuration class that inherits from the CommandTermCfg class.

Methods:

`__init__`(cfg, env)	Initialize the command manager.
`__new__`(args, *kwargs)

__init__(cfg: object, env: ManagerBasedRLEnv)[source]#

Initialize the command manager.

Parameters:

cfg¶ – The configuration object or dictionary (dict[str, CommandTermCfg]).
env¶ – The environment instance.

classmethod __new__(*args, **kwargs)#

class isaaclab_experimental.managers.CommandTerm[source]#

Bases: ManagerTermBase

The base class for implementing a command term.

A command term is used to generate commands for goal-conditioned tasks. For example, in the case of a goal-conditioned navigation task, the command term can be used to generate a target position for the robot to navigate to.

It implements a resampling mechanism that allows the command to be resampled at a fixed frequency. The resampling frequency can be specified in the configuration object. Additionally, it is possible to assign a visualization function to the command term that can be used to visualize the command in the simulator.

Methods:

`__init__`(cfg, env)	Initialize the command generator class.
`__new__`(args, *kwargs)

__init__(cfg: CommandTermCfg, env: ManagerBasedRLEnv)[source]#

Initialize the command generator class.

Parameters:

cfg¶ – The configuration parameters for the command generator.
env¶ – The environment object.

classmethod __new__(*args, **kwargs)#

class isaaclab_experimental.managers.EventManager[source]#

Bases: ManagerBase

Manager for orchestrating operations based on different simulation events (Warp-first for interval/reset).

Methods:

`__init__`(cfg, env)	Initialize the manager.
`__new__`(args, *kwargs)

__init__(cfg: object, env)[source]#

Initialize the manager.

This function is responsible for parsing the configuration object and creating the terms.

If the simulation is not playing, the scene entities are not resolved immediately. Instead, the resolution is deferred until the simulation starts. This is done to ensure that the scene entities are resolved even if the manager is created after the simulation has already started.

Parameters:

cfg¶ – The configuration object. If None, the manager is initialized without any terms.
env¶ – The environment instance.

classmethod __new__(*args, **kwargs)#

class isaaclab_experimental.managers.ManagerBase[source]#

Bases: ABC

Base class for all managers.

Methods:

`__init__`(cfg, env)	Initialize the manager.
`__new__`(args, *kwargs)

__init__(cfg: object, env: ManagerBasedEnv)[source]#

Initialize the manager.

This function is responsible for parsing the configuration object and creating the terms.

If the simulation is not playing, the scene entities are not resolved immediately. Instead, the resolution is deferred until the simulation starts. This is done to ensure that the scene entities are resolved even if the manager is created after the simulation has already started.

Parameters:

cfg¶ – The configuration object. If None, the manager is initialized without any terms.
env¶ – The environment instance.

classmethod __new__(*args, **kwargs)#

class isaaclab_experimental.managers.ManagerTermBase[source]#

Bases: ABC

Base class for manager terms.

Manager term implementations can be functions or classes. If the term is a class, it should inherit from this base class and implement the required methods.

Each manager is implemented as a class that inherits from the ManagerBase class. Each manager class should also have a corresponding configuration class that defines the configuration terms for the manager. Each term should the ManagerTermBaseCfg class or its subclass.

Example pseudo-code for creating a manager:

from isaaclab.utils.configclass import configclass
from isaaclab.utils.mdp import ManagerBase, ManagerTermBaseCfg


@configclass
class MyManagerCfg:
    my_term_1: ManagerTermBaseCfg = ManagerTermBaseCfg(...)
    my_term_2: ManagerTermBaseCfg = ManagerTermBaseCfg(...)
    my_term_3: ManagerTermBaseCfg = ManagerTermBaseCfg(...)


# define manager instance
my_manager = ManagerBase(cfg=ManagerCfg(), env=env)

Methods:

`__init__`(cfg, env)	Initialize the manager term.
`__new__`(args, *kwargs)

__init__(cfg: ManagerTermBaseCfg, env: ManagerBasedEnv)[source]#

Initialize the manager term.

Parameters:

cfg¶ – The configuration object.
env¶ – The environment instance.

classmethod __new__(*args, **kwargs)#

class isaaclab_experimental.managers.ObservationManager[source]#

Bases: ManagerBase

Manager for computing observation signals for a given world.

Observations are organized into groups based on their intended usage. This allows having different observation groups for different types of learning such as asymmetric actor-critic and student-teacher training. Each group contains observation terms which contain information about the observation function to call, the noise corruption model to use, and the sensor to retrieve data from.

Each observation group should inherit from the ObservationGroupCfg class. Within each group, each observation term should instantiate the ObservationTermCfg class. Based on the configuration, the observations in a group can be concatenated into a single tensor or returned as a dictionary with keys corresponding to the term’s name.

If the observations in a group are concatenated, the shape of the concatenated tensor is computed based on the shapes of the individual observation terms. This information is stored in the group_obs_dim dictionary with keys as the group names and values as the shape of the observation tensor. When the terms in a group are not concatenated, the attribute stores a list of shapes for each term in the group.

Note

When the observation terms in a group do not have the same shape, the observation terms cannot be concatenated. In this case, please set the ObservationGroupCfg.concatenate_terms attribute in the group configuration to False.

Observations can also have history. This means a running history is updated per sim step. History can be controlled per ObservationTermCfg (See the ObservationTermCfg.history_length and ObservationTermCfg.flatten_history_dim). History can also be controlled via ObservationGroupCfg where group configuration overwrites per term configuration if set. History follows an oldest to newest ordering.

The observation manager can be used to compute observations for all the groups or for a specific group. The observations are computed by calling the registered functions for each term in the group. The functions are called in the order of the terms in the group. The functions are expected to return a tensor with shape (num_envs, …).

If a noise model or custom modifier is registered for a term, the function is called to corrupt the observation. The corruption function is expected to return a tensor with the same shape as the observation. The observations are clipped and scaled as per the configuration settings.

Experimental (Warp-first) note:: Observation term functions follow a Warp-first signature and write into pre-allocated Warp buffers: func(env, out, **params) -> None.

Methods:

`__init__`(cfg, env)	Initialize observation manager.
`__new__`(args, *kwargs)

__init__(cfg: object, env: ManagerBasedEnv)[source]#

Initialize observation manager.

Parameters:

cfg¶ – The configuration object or dictionary (dict[str, ObservationGroupCfg]).
env¶ – The environment instance.

Raises:

ValueError – If the configuration is None.
RuntimeError – If the shapes of the observation terms in a group are not compatible for concatenation and the concatenate_terms attribute is set to True.

classmethod __new__(*args, **kwargs)#

class isaaclab_experimental.managers.RewardManager[source]#

Bases: ManagerBase

Manager for computing reward signals for a given world.

The reward manager computes the total reward as a sum of the weighted reward terms. The reward terms are parsed from a nested config class containing the reward manger’s settings and reward terms configuration.

The reward terms are parsed from a config class containing the manager’s settings and each term’s parameters. Each reward term should instantiate the RewardTermCfg class.

Note

The reward manager multiplies the reward term’s weight with the time-step interval dt of the environment. This is done to ensure that the computed reward terms are balanced with respect to the chosen time-step interval in the environment.

Methods:

`__init__`(cfg, env)	Initialize the reward manager.
`__new__`(args, *kwargs)

__init__(cfg: object, env: ManagerBasedRLEnv)[source]#

Initialize the reward manager.

Parameters:

cfg¶ – The configuration object or dictionary (dict[str, RewardTermCfg]).
env¶ – The environment instance.

classmethod __new__(*args, **kwargs)#

class isaaclab_experimental.managers.SceneEntityCfg[source]#

Bases: SceneEntityCfg

Scene entity configuration with an optional Warp joint mask.

Notes: - joint_mask is intended for Warp kernels only.

Methods:

`__new__`(args, *kwargs)
`__init__`([name, joint_names, joint_ids, ...])

classmethod __new__(*args, **kwargs)#

__init__(name: str = <factory>, joint_names: str | list[str] | None = <factory>, joint_ids: list[int] | slice = <factory>, fixed_tendon_names: str | list[str] | None = <factory>, fixed_tendon_ids: list[int] | slice = <factory>, body_names: str | list[str] | None = <factory>, body_ids: list[int] | slice = <factory>, object_collection_names: str | list[str] | None = <factory>, object_collection_ids: list[int] | slice = <factory>, preserve_order: bool = <factory>) → None#

class isaaclab_experimental.managers.TerminationManager[source]#

Bases: ManagerBase

Manager for computing done signals for a given world (Warp-first).

The termination manager computes the termination signal (also called dones) as a combination of termination terms. Each termination term is a function which takes the environment and a pre-allocated Warp boolean output buffer and fills it with per-env termination flags.

Methods:

`__init__`(cfg, env)	Initialize the manager.
`__new__`(args, *kwargs)

__init__(cfg: object, env: ManagerBasedRLEnv)[source]#

Initialize the manager.

This function is responsible for parsing the configuration object and creating the terms.

If the simulation is not playing, the scene entities are not resolved immediately. Instead, the resolution is deferred until the simulation starts. This is done to ensure that the scene entities are resolved even if the manager is created after the simulation has already started.

Parameters:

cfg¶ – The configuration object. If None, the manager is initialized without any terms.
env¶ – The environment instance.

classmethod __new__(*args, **kwargs)#

isaaclab_experimental.managers

Contents

isaaclab_experimental.managers#

Additional Public Classes#