上传 Task E 数据采集与过滤脚本

code/task_e_collection/task_e/collector.py

@@ -0,0 +1,399 @@
+"""Single-episode demo collection and success checking for Task E."""
+
+import numpy as np
+import torch
+from isaaclab.envs import ManagerBasedRLEnv
+from atec_rl_lab.utils import CartesianController
+from atec_rl_lab.tasks.task_e.env_cfg import (
+    TABLE_CENTER_X, TABLE_CENTER_Y, TABLE_TOP_Z,
+    BASKET_CENTER_X, BASKET_CENTER_Y,
+)
+
+from .config import (
+    ACTION_SCALE,
+    EE_BODY_NAME,
+    GRIPPER_OPEN_POS, GRIPPER_CLOSE_POS,
+    OBJ_GRIPPER_CLOSE_POS,
+    RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z,
+    DEFAULT_PLACE_QUAT_W,
+    BASKET_IN_X, BASKET_IN_Y,
+    OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Z, OBJ_SPAWN_Y_BANDS,
+    OBJ_HALF_EXTENTS, OBJ_BBOX_MARGIN, OBJ_GRASP_CENTER_OFFSETS,
+    OBJ_FINGER_CENTER_SERVO_STATES, OBJ_FINGER_CENTER_SERVO_GAIN,
+    OBJ_FINGER_CENTER_SERVO_MAX_XY, OBJ_FINGER_CENTER_SERVO_TARGET_Z,
+    OBJ_FINGER_CENTER_SERVO_MAX_Z,
+    WARMUP_STEPS, SETTLE_STEPS,
+)
+from .state_machine import PickPlaceStateMachine
+
+
+def _rerandomize_objects(env: ManagerBasedRLEnv, rng: np.random.Generator) -> None:
+    """Place each object randomly with AABB-based overlap rejection."""
+    placed: dict[int, tuple[float, float]] = {}  # obj_idx -> (x, y)
+
+    for obj_idx in [1, 2, 3]:
+        obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"]
+        y_min, y_max = OBJ_SPAWN_Y_BANDS[obj_idx]
+        hx, hy = OBJ_HALF_EXTENTS[obj_idx]
+
+        x = y = None
+        for _ in range(200):
+            cx = float(rng.uniform(OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX))
+            cy = float(rng.uniform(y_min, y_max))
+            # AABB overlap check against all already-placed objects
+            ok = all(
+                abs(cx - px) >= hx + OBJ_HALF_EXTENTS[pi][0] + OBJ_BBOX_MARGIN or
+                abs(cy - py) >= hy + OBJ_HALF_EXTENTS[pi][1] + OBJ_BBOX_MARGIN
+                for pi, (px, py) in placed.items()
+            )
+            if ok:
+                x, y = cx, cy
+                break
+
+        if x is None:  # fallback: band centre
+            x = (OBJ_SPAWN_X_MIN + OBJ_SPAWN_X_MAX) / 2.0
+            y = (y_min + y_max) / 2.0
+
+        placed[obj_idx] = (x, y)
+        state = obj.data.default_root_state[0:1].clone()
+        state[0, 0] = x
+        state[0, 1] = y
+        state[0, 2] = OBJ_SPAWN_Z
+        state[0, 7:] = 0.0   # zero velocities
+        obj.write_root_state_to_sim(state)
+
+    env.unwrapped.scene.write_data_to_sim()
+    env.unwrapped.sim.forward()
+
+
+_BASKET_MAX_Z = TABLE_TOP_Z + 0.15  # keep aligned with Task-E reward/termination bounds
+
+def check_objects_in_basket(env: ManagerBasedRLEnv, pick_objects: list[int]) -> bool:
+    """Return True only if every picked object is inside the basket region and settled."""
+    for obj_idx in pick_objects:
+        pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0]
+        if (abs(pos[0].item() - BASKET_CENTER_X) > BASKET_IN_X or
+                abs(pos[1].item() - BASKET_CENTER_Y) > BASKET_IN_Y or
+                pos[2].item() > _BASKET_MAX_Z):
+            return False
+    return True
+
+
+def basket_status_lines(env: ManagerBasedRLEnv, pick_objects: list[int]) -> list[str]:
+    """Return compact debug lines for picked objects against basket bounds."""
+    lines = []
+    for obj_idx in pick_objects:
+        pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0]
+        dx = pos[0].item() - BASKET_CENTER_X
+        dy = pos[1].item() - BASKET_CENTER_Y
+        z = pos[2].item()
+        inside = abs(dx) <= BASKET_IN_X and abs(dy) <= BASKET_IN_Y and TABLE_TOP_Z <= z <= _BASKET_MAX_Z
+        lines.append(
+            f"object_{obj_idx}: pos=({pos[0].item():.3f},{pos[1].item():.3f},{z:.3f}) "
+            f"d=({dx:+.3f},{dy:+.3f}) inside={inside}"
+        )
+    return lines
+
+
+def collect_one_demo(
+    env:         ManagerBasedRLEnv,
+    robot,
+    ik_ctrl:     CartesianController,
+    arm_ids:     list[int],
+    gripper_ids: list[int],
+    pick_objects: list[int],
+    device:      str,
+    default_jpos: torch.Tensor,
+    rng:         np.random.Generator,
+    camera=None,
+    trace: bool = False,
+    abort_failed_lift: bool = False,
+) -> dict | None:
+    """Run one full episode and return recorded data, or None on early termination.
+
+    Returns a dict with keys:
+      qpos    (T, 8)        absolute joint positions
+      qvel    (T, 8)        joint velocities
+      ee_pos  (T, 3)        end-effector position (world frame)
+      ee_quat (T, 4)        end-effector quaternion (w,x,y,z)
+      action  (T, 8)        env action = (joint_target - default_jpos) / ACTION_SCALE
+      frames  (T, H, W, 3)  RGB uint8 — only present when camera is given
+    """
+    env.reset()
+    robot.write_joint_state_to_sim(
+        robot.data.default_joint_pos,
+        torch.zeros_like(robot.data.default_joint_vel),
+    )
+
+    _rerandomize_objects(env, rng)      # write new object positions to sim + sim.forward()
+    default_jpos = robot.data.default_joint_pos.clone()
+
+    ee_home = torch.tensor([[RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z]],
+                            dtype=torch.float32, device=device)
+    eq_home = torch.tensor([DEFAULT_PLACE_QUAT_W], dtype=torch.float32, device=device)
+    g_open  = torch.tensor([GRIPPER_OPEN_POS], dtype=torch.float32, device=device)
+
+    robot.update(dt=env.unwrapped.physics_dt)
+    ik_ctrl.reset()
+
+    # Warm-up: drive arm to HOME position (not recorded)
+    for _ in range(WARMUP_STEPS):
+        _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids,
+                 ee_home, eq_home, g_open, default_jpos)
+
+    # Pre-compute grasp quaternions from actual object orientations after reset
+    sm = PickPlaceStateMachine(pick_objects, device)
+    for obj_idx in pick_objects:
+        obj_quat = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] \
+                       .data.root_state_w[0, 3:7]
+        sm.set_grasp_quat(obj_idx, obj_quat)
+
+    # Settle
+    for _ in range(SETTLE_STEPS):
+        _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids,
+                 ee_home, eq_home, g_open, default_jpos)
+
+    ik_ctrl.reset()
+
+    # ---- Recording loop ---- #
+    qpos_buf, qvel_buf, ee_pos_buf, ee_quat_buf, action_buf = [], [], [], [], []
+    frames_buf = [] if camera is not None else None
+    trace_stats: dict[str, dict] | None = {} if trace else None
+    ee_body_idx = None
+    finger_body_indices: tuple[int, int] | None = None
+    ee_body_ids, _ = robot.find_bodies(EE_BODY_NAME)
+    if len(ee_body_ids) > 0:
+        ee_body_idx = int(ee_body_ids[0])
+    link7_ids, _ = robot.find_bodies("link7")
+    link8_ids, _ = robot.find_bodies("link8")
+    if len(link7_ids) > 0 and len(link8_ids) > 0:
+        finger_body_indices = (int(link7_ids[0]), int(link8_ids[0]))
+
+    def _finger_center() -> torch.Tensor | None:
+        if finger_body_indices is None:
+            return None
+        f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach()
+        f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach()
+        return 0.5 * (f0 + f1)
+
+    def _servo_target_to_fingers(
+        state_name: str,
+        obj_key: str,
+        obj_pos: torch.Tensor,
+        ee_pos_des: torch.Tensor,
+    ) -> torch.Tensor:
+        obj_idx = int(obj_key.rsplit("_", 1)[1])
+        if state_name not in OBJ_FINGER_CENTER_SERVO_STATES.get(obj_idx, ()):
+            return ee_pos_des
+        finger_center = _finger_center()
+        if finger_center is None:
+            return ee_pos_des
+        grasp_offset = torch.tensor(
+            OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)),
+            dtype=torch.float32,
+            device=device,
+        )
+        grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos
+        xy_error = finger_center[:2] - grasp_center[:2]
+        err_norm = torch.linalg.norm(xy_error)
+        if err_norm.item() > 0.18:
+            return ee_pos_des
+        gain = OBJ_FINGER_CENTER_SERVO_GAIN.get(obj_idx, 0.85)
+        correction = -xy_error * gain
+        max_xy = OBJ_FINGER_CENTER_SERVO_MAX_XY.get(obj_idx, 0.08)
+        corr_norm = torch.linalg.norm(correction).clamp(min=1e-6)
+        if corr_norm.item() > max_xy:
+            correction = correction / corr_norm * max_xy
+        ee_pos_des = ee_pos_des.clone()
+        ee_pos_des[:2] = ee_pos_des[:2] + correction
+        if state_name in ("REACH", "CLOSE") and obj_idx in OBJ_FINGER_CENTER_SERVO_TARGET_Z:
+            target_rel_z = OBJ_FINGER_CENTER_SERVO_TARGET_Z[obj_idx]
+            z_error = target_rel_z - float((finger_center[2] - obj_pos[2]).item())
+            max_z = OBJ_FINGER_CENTER_SERVO_MAX_Z.get(obj_idx, 0.02)
+            z_correction = min(0.0, max(-max_z, z_error * gain))
+            ee_pos_des[2] = ee_pos_des[2] + z_correction
+        return ee_pos_des
+
+    def _update_trace(state_name: str, obj_key: str, obj_pos: torch.Tensor) -> None:
+        if trace_stats is None:
+            return
+        obj_idx = int(obj_key.rsplit("_", 1)[1])
+        grasp_offset = torch.tensor(
+            OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)),
+            dtype=torch.float32,
+            device=device,
+        )
+        grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos
+        if ee_body_idx is not None:
+            ee_pos = robot.data.body_pos_w[0, ee_body_idx, :3].detach()
+        else:
+            ee_pos = ik_ctrl.ee_pos_w[0].detach()
+        finger_center_dist = None
+        finger_body_gap = None
+        if finger_body_indices is not None:
+            f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach()
+            f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach()
+            finger_center = 0.5 * (f0 + f1)
+            finger_center_dist = float(torch.linalg.norm(grasp_center - finger_center).item())
+            finger_body_gap = float(torch.linalg.norm(f0 - f1).item())
+            finger_center_vec = [float(v) for v in (finger_center - grasp_center).detach().cpu().tolist()]
+        else:
+            finger_center_vec = None
+        gripper_jpos = robot.data.joint_pos[0, gripper_ids].detach()
+        gripper_gap = abs(float(gripper_jpos[0].item() - gripper_jpos[1].item()))
+        ee_dist = float(torch.linalg.norm(obj_pos - ee_pos).item())
+        ee_vec = [float(v) for v in (ee_pos - obj_pos).detach().cpu().tolist()]
+        obj_pos_cpu = [float(v) for v in obj_pos.detach().cpu().tolist()]
+        obj_stats = trace_stats.setdefault(
+            obj_key,
+            {
+                "initial_pos": obj_pos_cpu,
+                "final_pos": obj_pos_cpu,
+                "max_z": obj_pos_cpu[2],
+                "min_ee_dist": ee_dist,
+                "min_ee_vec": ee_vec,
+                "min_gripper_gap": gripper_gap,
+                "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0,
+                "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None,
+                "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0,
+                "states": {},
+            },
+        )
+        obj_stats["final_pos"] = obj_pos_cpu
+        obj_stats["max_z"] = max(float(obj_stats["max_z"]), obj_pos_cpu[2])
+        if ee_dist < float(obj_stats["min_ee_dist"]):
+            obj_stats["min_ee_dist"] = ee_dist
+            obj_stats["min_ee_vec"] = ee_vec
+        obj_stats["min_gripper_gap"] = min(float(obj_stats["min_gripper_gap"]), gripper_gap)
+        if finger_center_dist is not None:
+            if finger_center_dist < float(obj_stats["min_finger_center_dist"]):
+                obj_stats["min_finger_center_dist"] = finger_center_dist
+                obj_stats["min_finger_center_vec"] = finger_center_vec
+        if finger_body_gap is not None:
+            obj_stats["min_finger_body_gap"] = min(float(obj_stats["min_finger_body_gap"]), finger_body_gap)
+        st = obj_stats["states"].setdefault(
+            state_name,
+            {
+                "steps": 0,
+                "start_pos": obj_pos_cpu,
+                "end_pos": obj_pos_cpu,
+                "max_z": obj_pos_cpu[2],
+                "min_ee_dist": ee_dist,
+                "min_ee_vec": ee_vec,
+                "min_gripper_gap": gripper_gap,
+                "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0,
+                "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None,
+                "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0,
+            },
+        )
+        st["steps"] += 1
+        st["end_pos"] = obj_pos_cpu
+        st["max_z"] = max(float(st["max_z"]), obj_pos_cpu[2])
+        if ee_dist < float(st["min_ee_dist"]):
+            st["min_ee_dist"] = ee_dist
+            st["min_ee_vec"] = ee_vec
+        st["min_gripper_gap"] = min(float(st["min_gripper_gap"]), gripper_gap)
+        if finger_center_dist is not None:
+            if finger_center_dist < float(st["min_finger_center_dist"]):
+                st["min_finger_center_dist"] = finger_center_dist
+                st["min_finger_center_vec"] = finger_center_vec
+        if finger_body_gap is not None:
+            st["min_finger_body_gap"] = min(float(st["min_finger_body_gap"]), finger_body_gap)
+
+    def _gripper_target_values(obj_key: str, gripper_cmd: str) -> list[float]:
+        if gripper_cmd == "open":
+            return GRIPPER_OPEN_POS
+        obj_idx = int(obj_key.rsplit("_", 1)[1])
+        return OBJ_GRIPPER_CLOSE_POS.get(obj_idx, GRIPPER_CLOSE_POS)
+
+    while not sm.done:
+        state_name = sm.state
+        obj_key = sm.current_object_key
+        obj_pos_w = env.unwrapped.scene.rigid_objects[sm.current_object_key] \
+                        .data.root_pos_w[0].clone()
+        ee_pos_des, ee_quat_des, gripper_cmd = sm.tick(obj_pos_w)
+        ee_pos_des = _servo_target_to_fingers(state_name, obj_key, obj_pos_w, ee_pos_des)
+
+        arm_jpos_des   = ik_ctrl.compute(ee_pos_des.unsqueeze(0), ee_quat_des.unsqueeze(0))
+        gripper_vals   = _gripper_target_values(obj_key, gripper_cmd)
+        gripper_target = torch.tensor([gripper_vals], dtype=torch.float32, device=device)
+
+        full_target = robot.data.joint_pos.clone()
+        full_target[:, arm_ids]     = arm_jpos_des
+        full_target[:, gripper_ids] = gripper_target
+        env_action = (full_target - default_jpos) / ACTION_SCALE
+
+        # Record BEFORE stepping (obs at time t, action at time t)
+        qpos_buf.append(robot.data.joint_pos[0].cpu().numpy())
+        qvel_buf.append(robot.data.joint_vel[0].cpu().numpy())
+        ee_pos_buf.append(ik_ctrl.ee_pos_w[0].cpu().numpy())
+        ee_quat_buf.append(ik_ctrl.ee_quat_w[0].cpu().numpy())
+        action_buf.append(env_action[0].cpu().numpy())
+        if frames_buf is not None:
+            rgba = camera.data.output["rgb"][0].cpu().numpy()
+            frames_buf.append(rgba[:, :, :3])
+
+        _update_trace(state_name, obj_key, obj_pos_w)
+        _, _, terminated, truncated, _ = env.step(env_action)
+
+        if abort_failed_lift and state_name == "LIFT" and sm.state != "LIFT":
+            final_obj_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0]
+            lift_gain = float((final_obj_pos[2] - obj_pos_w[2]).item())
+            trace_gain = None
+            if trace_stats is not None and obj_key in trace_stats:
+                obj_stats = trace_stats[obj_key]
+                trace_gain = float(obj_stats["max_z"] - obj_stats["initial_pos"][2])
+            effective_gain = max(lift_gain, trace_gain if trace_gain is not None else lift_gain)
+            if effective_gain < 0.035:
+                print(
+                    f"[WARN] {obj_key} failed lift gate "
+                    f"(z_gain={effective_gain:.3f}) - aborting attempt."
+                )
+                return None
+
+        if terminated.any() or truncated.any():
+            if check_objects_in_basket(env, pick_objects):
+                print("[INFO] Episode ended after basket success; keeping demo.")
+                break
+            print("[WARN] Episode ended early — skipping demo.")
+            return None
+
+    result = {
+        "qpos":    np.stack(qpos_buf),
+        "qvel":    np.stack(qvel_buf),
+        "ee_pos":  np.stack(ee_pos_buf),
+        "ee_quat": np.stack(ee_quat_buf),
+        "action":  np.stack(action_buf),
+    }
+    if frames_buf is not None:
+        result["frames"] = np.stack(frames_buf)
+    if trace_stats is not None:
+        for obj_idx in pick_objects:
+            obj_key = f"object_{obj_idx}"
+            if obj_key not in trace_stats:
+                continue
+            final_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0]
+            final_pos_cpu = [float(v) for v in final_pos.detach().cpu().tolist()]
+            obj_stats = trace_stats[obj_key]
+            obj_stats["final_pos"] = final_pos_cpu
+            obj_stats["z_gain"] = float(obj_stats["max_z"] - obj_stats["initial_pos"][2])
+            obj_stats["lifted"] = bool(obj_stats["z_gain"] >= 0.035)
+            obj_stats["reward_lifted"] = bool(obj_stats["max_z"] >= TABLE_TOP_Z + 0.15)
+            obj_stats["basket_inside"] = check_objects_in_basket(env, [obj_idx])
+        result["trace"] = trace_stats
+    return result
+
+
+# ------------------------------------------------------------------ #
+# Internal helper
+# ------------------------------------------------------------------ #
+
+def _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids,
+             ee_pos, ee_quat, gripper_target, default_jpos):
+    """Single IK step toward a target pose (utility used during warm-up/settle)."""
+    arm_des = ik_ctrl.compute(ee_pos, ee_quat)
+    tgt = robot.data.joint_pos.clone()
+    tgt[:, arm_ids]     = arm_des
+    tgt[:, gripper_ids] = gripper_target
+    env.step((tgt - default_jpos) / ACTION_SCALE)
+    robot.update(dt=env.unwrapped.physics_dt)