| """Frozen SONIC v1.1 driving N robots at once from wrist targets. |
| |
| ``obs.pack_encoder`` builds one 1751-D vector per call from a full reference |
| clip. An RL rollout needs something different: many environments, no clip, and |
| a standing reference that never changes. Under those assumptions almost the |
| whole encoder vector is constant, so it is built once here and only the heading |
| (6) and the VR 3-point target (21) are rewritten each step. |
| |
| The history buffers and the push ordering mirror ``scripts/play_sonic.py`` |
| exactly -- history holds post-physics proprio together with the action that |
| produced it -- because SONIC is sensitive to that alignment. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| from .constants import ( |
| ACTION_CLIP, |
| DECODER_DIM, |
| DEFAULT_ANGLES, |
| ENCODER_DIM, |
| ENCODER_OFF, |
| FUTURE_FRAMES, |
| HIST_FRAMES, |
| LOWER_BODY_ISAAC_IDX, |
| MODE_IDS, |
| NUM_JOINTS, |
| TOKEN_DIM, |
| ) |
| from .math_np import heading_rel_6d |
| from .policy import SonicOnnxAgent |
|
|
|
|
| class BatchedSonicController: |
| """Wrist targets in, 29 joint-position targets out, for N environments. |
| |
| Teleop mode against a fixed standing reference: the legs are told to hold |
| the default stance, so whatever the base does is SONIC reacting to the arm |
| rather than commanded locomotion. |
| """ |
|
|
| def __init__( |
| self, |
| checkpoint: str | Path, |
| num_envs: int, |
| *, |
| agent: SonicOnnxAgent | None = None, |
| ) -> None: |
| self.num_envs = int(num_envs) |
| self.agent = agent if agent is not None else SonicOnnxAgent(checkpoint, batched=True) |
| self.default = np.asarray(DEFAULT_ANGLES, dtype=np.float64) |
|
|
| self._enc = np.zeros((self.num_envs, ENCODER_DIM), dtype=np.float32) |
| self._enc[:, ENCODER_OFF["encoder_mode_4"][0]] = float(MODE_IDS["teleop"]) |
| |
| |
| |
| lower = self.default[LOWER_BODY_ISAAC_IDX].astype(np.float32) |
| a, b = ENCODER_OFF["motion_joint_positions_lowerbody_10frame_step5"] |
| self._enc[:, a:b] = np.tile(lower, FUTURE_FRAMES) |
|
|
| self._dec = np.zeros((self.num_envs, DECODER_DIM), dtype=np.float32) |
| self._hist = { |
| "ang_vel": np.zeros((self.num_envs, HIST_FRAMES, 3), dtype=np.float32), |
| "q_rel": np.zeros((self.num_envs, HIST_FRAMES, NUM_JOINTS), dtype=np.float32), |
| "dq": np.zeros((self.num_envs, HIST_FRAMES, NUM_JOINTS), dtype=np.float32), |
| "action": np.zeros((self.num_envs, HIST_FRAMES, NUM_JOINTS), dtype=np.float32), |
| "gravity": np.zeros((self.num_envs, HIST_FRAMES, 3), dtype=np.float32), |
| } |
| self._last_action = np.zeros((self.num_envs, NUM_JOINTS), dtype=np.float32) |
| self._primed = np.zeros(self.num_envs, dtype=bool) |
|
|
| def reset(self, env_ids: np.ndarray | None = None) -> None: |
| """Forget history for these environments; the next step re-primes them.""" |
| if env_ids is None: |
| self._primed[:] = False |
| self._last_action[:] = 0.0 |
| return |
| idx = np.asarray(env_ids, dtype=np.int64).reshape(-1) |
| if idx.size: |
| self._primed[idx] = False |
| self._last_action[idx] = 0.0 |
|
|
| def step( |
| self, |
| *, |
| joint_pos: np.ndarray, |
| joint_vel: np.ndarray, |
| ang_vel: np.ndarray, |
| gravity: np.ndarray, |
| root_quat_wxyz: np.ndarray, |
| vr_pos: np.ndarray, |
| vr_quat: np.ndarray, |
| ) -> np.ndarray: |
| """One 50 Hz control step for every environment. |
| |
| All arrays are batched over N. ``joint_pos`` / ``joint_vel`` are (N, 29) |
| in Isaac Lab SONIC order, ``vr_pos`` is (N, 3, 3) and ``vr_quat`` |
| (N, 3, 4 wxyz), both in the pelvis frame in left-wrist, right-wrist, |
| torso order. Returns the (N, 29) clipped network action; the caller |
| scales it into joint targets. |
| """ |
| q_rel = (np.asarray(joint_pos, dtype=np.float32) - self.default).astype(np.float32) |
| dq = np.asarray(joint_vel, dtype=np.float32) |
| ang = np.asarray(ang_vel, dtype=np.float32) |
| grav = np.asarray(gravity, dtype=np.float32) |
|
|
| self._record(ang, q_rel, dq, grav) |
|
|
| quat = np.asarray(root_quat_wxyz, dtype=np.float64) |
| ident = np.zeros_like(quat) |
| ident[:, 0] = 1.0 |
| a, b = ENCODER_OFF["motion_anchor_orientation_heading"] |
| self._enc[:, a:b] = heading_rel_6d(quat, ident).astype(np.float32) |
| a, b = ENCODER_OFF["vr_3point_local_target"] |
| self._enc[:, a:b] = np.asarray(vr_pos, dtype=np.float32).reshape(self.num_envs, 9) |
| a, b = ENCODER_OFF["vr_3point_local_orn_target"] |
| self._enc[:, a:b] = np.asarray(vr_quat, dtype=np.float32).reshape(self.num_envs, 12) |
|
|
| self._dec[:, :TOKEN_DIM] = self.agent.encode(self._enc) |
| i = TOKEN_DIM |
| |
| for key in ("ang_vel", "q_rel", "dq", "action", "gravity"): |
| buf = self._hist[key] |
| n = buf.shape[1] * buf.shape[2] |
| self._dec[:, i : i + n] = buf.reshape(self.num_envs, n) |
| i += n |
| if i != DECODER_DIM: |
| raise RuntimeError(f"decoder pack {i} != {DECODER_DIM}") |
|
|
| action = np.clip(self.agent.decode(self._dec), -ACTION_CLIP, ACTION_CLIP) |
| self._last_action = action.astype(np.float32) |
| return self._last_action |
|
|
| def joint_targets(self, action: np.ndarray, scale: np.ndarray) -> np.ndarray: |
| """``default + scale * action`` for the 29 SONIC joints.""" |
| return self.default + np.asarray(scale, dtype=np.float64) * np.asarray(action, dtype=np.float64) |
|
|
| def _record( |
| self, ang: np.ndarray, q_rel: np.ndarray, dq: np.ndarray, grav: np.ndarray |
| ) -> None: |
| """Append this frame, filling a freshly reset environment's whole window.""" |
| frame = {"ang_vel": ang, "q_rel": q_rel, "dq": dq, "action": self._last_action, "gravity": grav} |
| fresh = ~self._primed |
| for key, buf in self._hist.items(): |
| buf[:, :-1] = buf[:, 1:] |
| buf[:, -1] = frame[key] |
| if fresh.any(): |
| buf[fresh] = frame[key][fresh][:, None, :] |
| self._primed[:] = True |
|
|
