| """Measure execution error for demo.solution_pca in Task E. |
| |
| Uses simulator internals only for debugging: object root, gripper_base, link7, |
| and link8 positions. The submission policy still only receives observations. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import os |
| import sys |
| import time |
|
|
| from isaaclab.app import AppLauncher |
|
|
|
|
| parser = argparse.ArgumentParser() |
| parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper") |
| parser.add_argument("--seed", type=int, default=12) |
| parser.add_argument("--object", type=int, default=3) |
| parser.add_argument("--max_steps", type=int, default=2500) |
| parser.add_argument("--solution_module", type=str, default="solution_pca") |
| AppLauncher.add_app_launcher_args(parser) |
| args_cli = parser.parse_args() |
| args_cli.enable_cameras = True |
|
|
| repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) |
| demo_dir = os.path.join(repo_root, "demo") |
| if repo_root not in sys.path: |
| sys.path.insert(0, repo_root) |
| if demo_dir not in sys.path: |
| sys.path.insert(0, demo_dir) |
|
|
| app_launcher = AppLauncher(args_cli) |
| simulation_app = app_launcher.app |
|
|
| import gymnasium as gym |
| import importlib |
| import numpy as np |
| import torch |
| from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent |
| from isaaclab_tasks.utils import parse_env_cfg |
|
|
| import atec_rl_lab.tasks |
|
|
|
|
| def main() -> None: |
| env_cfg = parse_env_cfg(args_cli.task, device=args_cli.device, num_envs=1) |
| env_cfg.seed = args_cli.seed |
| env = gym.make(args_cli.task, cfg=env_cfg) |
| if isinstance(env.unwrapped, DirectMARLEnv): |
| env = multi_agent_to_single_agent(env) |
|
|
| module = importlib.import_module(args_cli.solution_module) |
| AlgSolution = module.AlgSolution |
| policy = AlgSolution() |
| try: |
| obs, _ = env.reset(seed=args_cli.seed) |
| policy.reset_episode() |
| robot = env.unwrapped.scene.articulations["robot"] |
| obj = env.unwrapped.scene.rigid_objects[f"object_{args_cli.object}"] |
| gb_id = int(robot.find_bodies("gripper_base")[0][0]) |
| link7_id = int(robot.find_bodies("link7")[0][0]) |
| link8_id = int(robot.find_bodies("link8")[0][0]) |
| obj_initial = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) |
|
|
| best = { |
| "finger_dist": (999.0, None, 0, None), |
| "gb_dist": (999.0, None, 0, None), |
| "max_z_gain": (-999.0, None, 0, None), |
| "pin_finger_err": (999.0, None, 0, None), |
| "pin_gb_err": (999.0, None, 0, None), |
| } |
| stage_best = {} |
| pin_err_sum = {"finger": 0.0, "gb": 0.0} |
| pin_err_n = 0 |
| total_reward = 0.0 |
| start = time.time() |
| for step in range(args_cli.max_steps): |
| with torch.inference_mode(): |
| resp = policy.predicts(obs, total_reward) |
| action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1) |
| obs, reward, terminated, truncated, info = env.step(action) |
| sim_dt = info["Step_dt"] |
| total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt |
|
|
| obj_pos = obj.data.root_pos_w[0, :3].detach().cpu().numpy().astype(np.float64) |
| gb = robot.data.body_pos_w[0, gb_id, :3].detach().cpu().numpy().astype(np.float64) |
| f7 = robot.data.body_pos_w[0, link7_id, :3].detach().cpu().numpy().astype(np.float64) |
| f8 = robot.data.body_pos_w[0, link8_id, :3].detach().cpu().numpy().astype(np.float64) |
| finger = 0.5 * (f7 + f8) |
| qpos = policy._obs_qpos(obs) |
| pin_finger = policy.ik.finger_center_world(qpos) |
| pin_gb_b, _ = policy.ik.fk_base(qpos[:6]) |
| pin_gb = module.BASE_POS_W + module.R_W_B @ pin_gb_b |
| gap = float(np.linalg.norm(f7 - f8)) |
| fd = float(np.linalg.norm(finger - obj_pos)) |
| gd = float(np.linalg.norm(gb - obj_pos)) |
| pfe = float(np.linalg.norm(pin_finger - finger)) |
| pge = float(np.linalg.norm(pin_gb - gb)) |
| pin_err_sum["finger"] += pfe |
| pin_err_sum["gb"] += pge |
| pin_err_n += 1 |
| zg = float(obj_pos[2] - obj_initial[2]) |
| plan_idx = getattr(policy, "plan_idx", -1) |
| target_step = getattr(policy, "step_in_target", -1) |
| label = "none" |
| plan = getattr(policy, "plan", None) |
| if isinstance(plan, list) and 0 <= plan_idx < len(plan): |
| label = getattr(plan[plan_idx], "label", str(plan_idx)) |
| stage = stage_best.setdefault( |
| label, |
| { |
| "min_finger": (999.0, None, 0, None), |
| "max_z_gain": (-999.0, None, 0, None), |
| "min_gap": (999.0, 0), |
| "last": None, |
| }, |
| ) |
| if fd < stage["min_finger"][0]: |
| stage["min_finger"] = (fd, finger - obj_pos, step, (plan_idx, target_step, gap, qpos[6], qpos[7])) |
| if zg > stage["max_z_gain"][0]: |
| stage["max_z_gain"] = (zg, obj_pos.copy(), step, (plan_idx, target_step, gap, qpos[6], qpos[7])) |
| if gap < stage["min_gap"][0]: |
| stage["min_gap"] = (gap, step) |
| stage["last"] = (finger - obj_pos, obj_pos.copy(), gap, qpos[6], qpos[7], step) |
| if fd < best["finger_dist"][0]: |
| best["finger_dist"] = (fd, finger - obj_pos, step, (plan_idx, target_step, gap)) |
| if gd < best["gb_dist"][0]: |
| best["gb_dist"] = (gd, gb - obj_pos, step, (plan_idx, target_step, gap)) |
| if zg > best["max_z_gain"][0]: |
| best["max_z_gain"] = (zg, obj_pos.copy(), step, (plan_idx, target_step, gap)) |
| if pfe < best["pin_finger_err"][0]: |
| best["pin_finger_err"] = (pfe, pin_finger - finger, step, (plan_idx, target_step, gap)) |
| if pge < best["pin_gb_err"][0]: |
| best["pin_gb_err"] = (pge, pin_gb - gb, step, (plan_idx, target_step, gap)) |
| if bool(terminated.item() or truncated.item()): |
| break |
|
|
| final = obj.data.root_pos_w[0, :3].detach().cpu().numpy().astype(np.float64) |
| print(f"[EXEC_DEBUG] seed={args_cli.seed} obj={args_cli.object} score={total_reward:.2f} wall={time.time()-start:.1f}s") |
| print(f"[EXEC_DEBUG] initial=({obj_initial[0]:.4f},{obj_initial[1]:.4f},{obj_initial[2]:.4f}) final=({final[0]:.4f},{final[1]:.4f},{final[2]:.4f})") |
| if pin_err_n: |
| print(f"[EXEC_DEBUG] pin_mean_err finger={pin_err_sum['finger']/pin_err_n:.4f} gb={pin_err_sum['gb']/pin_err_n:.4f}") |
| for key, (value, vec, step, meta) in best.items(): |
| if vec is None: |
| print(f"[EXEC_DEBUG] {key}=none") |
| elif key == "max_z_gain": |
| print(f"[EXEC_DEBUG] {key}={value:.4f} obj=({vec[0]:.4f},{vec[1]:.4f},{vec[2]:.4f}) step={step} meta={meta}") |
| else: |
| print(f"[EXEC_DEBUG] {key}={value:.4f} vec=({vec[0]:+.4f},{vec[1]:+.4f},{vec[2]:+.4f}) step={step} meta={meta}") |
| for label, stats in stage_best.items(): |
| if not any(k in label for k in ("reach", "insert", "close", "lift", "mid", "release")): |
| continue |
| fd, fvec, fstep, fmeta = stats["min_finger"] |
| zg, zobj, zstep, zmeta = stats["max_z_gain"] |
| last = stats["last"] |
| if fvec is None or zobj is None or last is None: |
| continue |
| lvec, lobj, lgap, lq7, lq8, lstep = last |
| print( |
| f"[STAGE_DEBUG] label={label} min_fd={fd:.4f} " |
| f"min_vec=({fvec[0]:+.4f},{fvec[1]:+.4f},{fvec[2]:+.4f}) " |
| f"min_meta={fmeta} max_z_gain={zg:.4f} " |
| f"z_obj=({zobj[0]:.4f},{zobj[1]:.4f},{zobj[2]:.4f}) z_meta={zmeta} " |
| f"last_vec=({lvec[0]:+.4f},{lvec[1]:+.4f},{lvec[2]:+.4f}) " |
| f"last_obj=({lobj[0]:.4f},{lobj[1]:.4f},{lobj[2]:.4f}) " |
| f"last_gap={lgap:.4f} last_q=({lq7:.4f},{lq8:.4f}) last_step={lstep}" |
| ) |
| finally: |
| env.close() |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| main() |
| finally: |
| simulation_app.close() |
|
|
