Randomizing motor strength, offset, and lag similar to isaacgym

[ammousa]

Hi everyone,

I’m migrating from Isaac Gym (spicifically walk-these-ways-go2 repo) to Isaac Lab and looking to replicate the following domain randomization parameters:

Cfg.domain_rand.randomize_motor_strength = True
Cfg.domain_rand.motor_strength_range = [0.9, 1.1]

Cfg.domain_rand.randomize_motor_offset = True
Cfg.domain_rand.motor_offset_range = [-0.02, 0.02]

Cfg.domain_rand.randomize_lag_timesteps = True
Cfg.domain_rand.lag_timesteps = 6

I’m using ActuatorNetMLP and would like to ask:

1. Is there a recommended way to randomize motor strength (i.e., torque scaling) for MLP actuators?
2. Is motor offset randomization (bias on position targets) supported?
3. How can I implement action lag or random lag timesteps per environment?

Would appreciate any guidance on native support or best practices for implementing these in Isaac Lab.

Thanks!

[RandomOakForest]

Thank you for posting this. Here's some guidance for migrating your domain randomization parameters from Isaac Gym (with walk-these-ways-go2) to Isaac Lab, specifically for an environment using ActuatorNetMLP actuators. This is based strictly on the official Isaac Lab documentation as of July 2025.

1. Randomizing Motor Strength (Torque Scaling) for ActuatorNetMLP

Isaac Lab does not offer built-in per-environment randomization for motor strength within the actuator model configuration itself (including ActuatorNetMLP). However, you can implement this in a manner analogous to Isaac Gym, by scaling the actuator outputs or its configuration parameters at runtime:

• Best Practice: At each environment reset (or at the start of every episode), sample a scaling factor from your desired range (e.g., [0.9, 1.1]), and multiply either:
  • The action sent to the actuator, or
  • The torque/equivalent output of the actuator before applying to the simulation.
• If your environment batches actions, you can maintain a per-environment scaling tensor.
• You may also extend the actuator configuration dynamically, by modifying its internal buffers. This applies to both neural and physics-based actuators because the output interfaces are unified.¹

Reference: See how actuator gains and limits are handled in isaaclab.actuators.ActuatorBase, which most actuator models inherit. The configuration does not natively support random per-env scaling, so you must implement runtime scaling externally.

2. Motor Offset Randomization Support

Motor offset randomization (i.e., adding a bias to the position targets of the actuators) is not directly a feature of actuator models, but you can insert this through the action processing pipeline:

• Use the offset parameter in your JointActionCfg or JointPositionActionCfg (see isaaclab.envs.mdp.actions.actions_cfg.JointActionCfg).
• Before sending your action vector to the environment, add a sampled offset (from e.g. [-0.02, 0.02]) to the relevant elements.
• You can randomize this offset per environment either on reset or per episode.

Example:

# action: (num_envs, action_dim)
random_offsets = torch.rand_like(action) * 0.04 - 0.02  # Uniform in [-0.02, 0.02]
action_with_offset = action + random_offsets

• You can also configure the offset argument of the action config per environment, but typically this is easier to do in your action preprocessing pipeline.²

3. Implementing Action Lag / Random Lag Timesteps per Environment

Isaac Lab provides a buffer utility for this—use isaaclab.utils.buffers.DelayBuffer:

• Instantiate a DelayBuffer of sufficient history length (should equal your max lag).
• For each environment, set the desired lag (either fixed, or randomly per episode) via the set_time_lag method.
• When you step the environment, push the new actions into the buffer and retrieve the delayed actions for each environment.
• Apply these delayed actions to the actuators, and pass new ones to the buffer.

Example API use (from the docs):

from isaaclab.utils.buffers import DelayBuffer
buffer = DelayBuffer(history_length=MAX_LAG, batch_size=NUM_ENVS, device=device)
# At episode reset, for each environment:
buffer.set_time_lag(lag_timesteps_tensor)  # can be a tensor of random integers in [0, MAX_LAG]
# When stepping:
delayed_actions = buffer.compute(new_actions)

• This natively supports random per-environment lag.³

Summary Table

Feature	Isaac Lab Native Support?	Recommended Implementation	Reference
Motor Strength (Torque Scale)	No per-env, config only global	Sample/multiply post-action or buffer per episode	1
Motor Offset Randomization	Configurable in action pipeline	Add sampled offset to position targets per env	2
Action Lag/Random Lag	Yes, via DelayBuffer	Use DelayBuffer, set per-env lag values	3

Implementation Best Practices

• Modularity: Implement randomization in a utility module, so it can easily be switched off or plugged into various envs.
• Reproducibility: Set and log random seeds for all per-episode samples.
• Reset Consistency: Always sample new parameters/offsets on env reset or episode start.

Key Isaac Lab API References

• Actuators: isaaclab.actuators.ActuatorBase and subclasses¹
• Action Processing: isaaclab.envs.mdp.actions.actions_cfg.JointActionCfg²
• Delay Buffer: isaaclab.utils.buffers.DelayBuffer³

Footnotes

1. https://isaac-sim.github.io/IsaacLab/main/source/api/lab/isaaclab.actuators.html ↩ ↩² ↩³

2. https://isaac-sim.github.io/IsaacLab/main/source/api/lab/isaaclab.envs.mdp.html ↩ ↩² ↩³

3. https://isaac-sim.github.io/IsaacLab/main/source/api/lab/isaaclab.utils.html ↩ ↩² ↩³