mouth_perpendicular_to_ground gaté par la down-gate segmentée.

Reward the mouth tip x-axis being vertical (pointing down) during the approach phase. A perfectly perpendicular contact gives alignment=1; horizo

L1 companion to multistage_height_target.

Multi-waypoint Gaussian on trunk z.

L1 companion to multistage_pose_target_match.

Multi-waypoint variant of interpolated_pose_target_match. waypoints: [{"frac": 0.0, "overrides": None}, {"frac": 0.4, "overrides"

Penalize neck action accelerations (action_t - 2*action_{t-1} + action_{t-2}). Neck joints are indices 5-8 (4 joints total). Args:

Penalize the rate of change of neck actions (action_t - action_{t-1}). Neck joints are indices 5-8 (4 joints total). Args: env:

Penalize neck/head joint position deviation from default (L2 squared). Uses find_joints() every call to avoid stale cached indices when the same

Penalize neck joint velocities to keep head stable. Neck joints are indices 5-8 (4 joints total). Args: env: The environment

Pénalise la vitesse des joints du cou pendant la DESCENTE+palier (freine le piqué de la tête). Coût = mean(joint_vel²) sur les joints donnés,

Penalize feet in the air when the commanded speed is below threshold. Discourages marching in place when the robot should stand still. Returns th

Reward trunk_z tracking a sin-interpolated target between stand and sit heights. Used for the sitstand task instead of joint-angle matching for t

Reward matching a target pose, weighted by phase-cycle command. Generic helper for phase-conditioned tasks (e.g. sit/stand). The command enco

Ramp a UniformPoseCommand's per-dim ranges over training. range_stages: list of {step: int, ranges: tuple[(lo, hi), ...]}. The first stage ap

L1 companion to ``pose_target_match`` (constant gradient toward target).

Always-on Gaussian on joint positions vs a target pose. Non-phase analog of ``phase_pose_match``: useful for episodic tasks (e.g. the sit env

Multiplicative goal score vs the commanded posture (height·upright·pose [·head]). The posture-conditioned version of ``standing_composite_sco

Gaussian on trunk z against the commanded posture's target height.

L1 companion to ``posture_height_gaussian`` — the transition driver. While the robot rests in the *wrong* posture this charges a constant per

L1 companion to ``posture_pose_match`` (constant gradient to target).

Gaussian pose-match against the commanded posture's target pose.

Upward-vz reward, active only when STAND is commanded and z < max_height. The standup-env lesson: destination-only rewards have zero gradient at

Reward trunk stillness while AT the commanded posture, upright. Generalizes ``seated_stillness`` to both rest states: exp(-(|v|/std)²) gated

Projected gravity vector in body frame. Returns the gravity vector projected into the robot's body frame, representing pure orientation witho

projected_gravity with a per-env constant IMU mounting misalignment.

Update push velocity range based on training progress. Starts with no/small pushes to learn clean walking, then gradually increases to build

Per-episode joint-friction randomization for the BAM actuator (NON-accumulating). Under BAM, MuJoCo's dof_frictionloss is zeroed (BAM computes fr

Randomize base orientation at episode start to force reactive behavior. Adds random pitch and roll to the robot's base orientation at the start o

Randomize body CoM (body_ipos) per episode WITHOUT accumulating. Drop-in replacement for the buggy mdp.randomize_field(add, body_ipos, reset).

Randomize firmware PD gains per episode (NON-accumulating). Under the canonical BAM actuator (``bam.mjlab.BamActuator``) gains are scaled per

Scale a per-dof model field (e.g. dof_frictionloss/dof_damping) per episode WITHOUT accumulating: restore nominal, then apply a fresh scale.

Randomize IMU sensor mounting orientation by small angles. Simulates slight mounting errors or calibration offsets in the real robot. The

Randomize body mass and inertia together with the same scaling factor. This maintains physical consistency - mass and inertia must scale together

Raw accelerometer reading (includes gravity + linear acceleration). Returns normalized raw accelerometer which mimics what a real IMU measures.

Reward foot air time only when at zero command AND robot has high velocity (recovering from push). This encourages the robot to take steps to rec

One-shot bounty on a COMPLETED recovery: fires on the frame where an env that has been fallen (tilt > fallen_tilt for ≥ min_fallen_s) becomes

A model card that says how to run the policy on a robot, generated so it cannot go stale.

Reset cached action history for environments that are being reset. This is critical for action rate and acceleration penalty terms. This

Place the ball in front of the (right) foot; store the kick direction. ``offset`` is the nominal ball-center position in the robot's yaw frame:

Départ en ROULEMENT sans glissement (élan aux roues). Tire une vitesse d'avance v par env ; met la vitesse LINÉAIRE de base (x monde) = v ET

Reset to a standing start or a mid-roll state (reverse curriculum). Standing bucket: upright (±standing_tilt_max pitch/roll noise), random yaw,

Warm-start a fraction of reset environments with a random forward velocity. The robot spawns already moving in its body-forward direction, so it

Step-staged reward weight curriculum. mjlab 1.3.0 dropped the built-in ``mdp.reward_weight`` helper, so microduck provides its own. ``weight_

Sim rollout using bam's MujocoController on a vanilla MuJoCo step loop. Pros: 200 Hz inner-step logging, no torch/mjwarp. Cons: not the exact

Sim rollout via the actual mjlab testbench env (same BAM M6 the policy was trained against). Boots make_testbench_env_cfg() with num_envs=1, over

Terminate when the trunk drops below ``min_height`` in world z. Utilisé par roller_slope comme « tombé dans le vide » : le terrain a un plat

(lateral-axis world-z)² — dense gradient toward a sagittal roll. Positive quantity; use a negative weight. Zero when standing, zero through a

Reward head-ground contact while rotating forward mid-roll. contact × window(accum ∈ [angle_lo, angle_hi]) × clamp(ω_fwd/rate_norm, 0, 1) × (

Broad height Gaussian × completion gate — pull up to standing height.

standing_composite_score × completion gate. The big annuity: once the roll is (nearly) complete, every step spent standing at HOME pose pays

Tight-std upright × height Gaussians × completion gate — the last mile. Run-4 fix for the 27°-lean / 1-cm-crouch end basin: the broad landing

Body-frame lateral (y) linear velocity² — keeps the roll straight.

max(0, |ω_y| − omega_max)² — quadratic tax on whip-speed rotation. Positive quantity; use a negative weight. Complements the paid-rate cap in

Pay increments of the progress frontier, up to one full roll. reward = Δ(min(max_accum, target)) / (step_dt · target), CAPPED at max_paid_rat

com_upward_velocity × late-roll gate — bootstrap the exit rise. The second half of a roulade (supine → sitting-up → standing) is the face-up

Rotation out of the sagittal plane: body-frame ω_x² + ω_z² (positive; use a negative weight). ω_y is the roll axis and stays free.

SELF-NEGATING height L1 below target, active only after roll completion. Returns −max(0, target − z) × completion_gate — use a POSITIVE weight

Linear cos(tilt) × completion gate — bootstrap pull toward vertical. Gradient from ANY orientation (the composite is near-zero far from the g

Event de reset : tire une masse d'objet 'tenu dans la bouche' par env (kg), stockée sur env._mouth_payload_kg. Utilisée par apply_mouth_payload_fo

Reward trunk stillness while seated UPRIGHT: |v| Gaussian, z- and tilt-gated. exp(-(|v|/vel_std)²) · smoothstep(z) · smoothstep(tilt). The z gate

Set the robot to a prone (belly-down) orientation for stand-up training. Rotates the robot 90° forward around the pitch axis (Y) so the front/bel

Reset to a random ground state: face-down, face-up, sitting, or standing. Broader than ``set_random_prone_orientation`` — used by the stand-up en

Binary reward: 1 while the sensed foot touches the terrain. Single-foot variant of ``feet_grounded_reward`` — used to pin the SUPPORT foot du

Reward single-support (a skating stride), mildly discourage the swizzle. Real skating is a STRIDE: push off one blade while the other swings, i.e

Positive reward for trunk-ground contact WHILE upright. Gated additionally on the trunk's body-frame +Z axis pointing in roughly the world-up

Bonus for low body angular velocity. Phase-gated when ``command_name`` is set (sit window of a phase command). Always-on otherwise, optionall

Reward feet air time only when pushing (cmd_x > 0). Encourages the robot to lift each foot during the recovery phase of the skating stroke ra

Run the network on plausible inputs and refuse a NaN/inf or a saturated output. Not a physics rehearsal — `scripts/infer_policy.py` is that — but

Les deux lames au sol pendant le spin — empêche « je saute et je vrille ». Variante de `grounded_reward` du swizzle, qui n'est pas réutilisable i

Bootstrap L1 : gradient constant vers la cible même quand la gaussienne de `spin_rate_track` sature loin de la cible. À utiliser avec un poids

Objectif principal du spin : suivre la vitesse de lacet cible ω*(φ). ω_z est pris en repère corps (c'est ce que voit le gyro de l'IMU, donc ce qu

Coût ‖v_xy‖² du tronc : tourner SUR PLACE, et tuer l'élan d'entrée. Pas d'état de référence (contrairement à une dérive mesurée depuis le reset),

Récompense la rotation EN ROULEMENT (et non en patinage). Pour un spin anti-horaire, le patin gauche recule et le droit avance ; les 4 roues

Update the relative number of standing environments based on training progress. Args: env: The RL environment env_ids: Environmen

Simple time-based phase for standing task. Returns a scalar phase value that cycles from 0 to 1 based on time. This allows the policy to have

Binary bonus: 1.0 iff height, uprightness AND pose are all within tol. Creates a discrete goal-state attractor that gradient-based pose/upright/

Reward staying still when command is near zero. Returns exp(-body_vel² / vel_std²) when command < threshold, else 0. This is monotonically de

exp(-error^2 / std^2) reward for single-joint position tracking.

Mutate a termination term's params at scheduled steps. TerminationManager keeps its own deepcopy of the cfg dict, so the live term_cfgs list

Curriculum de raideur pour roller_slope (pas de vitesse commandée). Progression basée sur la distance en x parcourue depuis l'origine de spawn.

A graph that ignores its input is not a policy — the shape gate alone would pass it.

A walking policy is perpetual too, and goes in a slot — no hold, no unwind, no skill.

Verrou sur la classe de bug qui rendait la policy violente. mdp.py mélange DEUX conventions de signe : certaines fonctions de pénalité renvoi