Datasets:

Neptune-T
/

DragMesh-3-Scene

"""
Evaluate an rl_games PPO checkpoint with HandDrag task metrics.
This complements ``ppo/train.py --play``: rl_games prints reward/steps only,
while this script writes the task metrics needed for baseline tables.
Example:
    python scripts/evaluate_ppo_baseline.py \
        --object_id 45936 \
        --checkpoint runs/hand_drag_ppo_45936/nn \
        --checkpoint-kind latest \
        --episodes 20
"""

import argparse
import csv
import glob
import json
import os
import sys
from pathlib import Path

import yaml

# Isaac Gym MUST be imported before torch.
from isaacgym import gymapi, gymtorch  # noqa: F401
import torch
from torch import nn


PROJECT_ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT_ROOT))

from dataset.geometric.hand_object_gym import HandObjectGym, N_HAND_DOFS  # noqa: E402
from ppo.hand_drag_task import HandDragTask  # noqa: E402
from ppo.rlgames_wrapper import resolve_handle_link_name  # noqa: E402

# Make sure the vendored fla package is importable for GLA checkpoints.
_FLA_ROOT = str((PROJECT_ROOT / "flash-linear-attention").resolve())
if _FLA_ROOT not in sys.path:
    sys.path.insert(0, _FLA_ROOT)


def _is_gla_checkpoint(model_state):
    return any(
        k.startswith("a2c_network.gla.") or k.startswith("a2c_network.token_proj")
        for k in model_state
    )


class RLGamesActor(nn.Module):
    """Actor matching configs/train/mlp/ppo.yaml.
    Supports both deterministic mu and stochastic Gaussian sampling.
    Stochastic mode loads ``a2c_network.sigma`` (logstd, shape [act_dim]),
    which is what rl_games trains with under ``fixed_sigma=True``. The
    deterministic mode is what a hand-engineered controller would do at
    deploy time; stochastic mode is what produced the training reward
    curve, so reporting both makes the sim2eval gap visible.
    """

    def __init__(self, checkpoint, device, stochastic=False):
        super().__init__()
        model = checkpoint["model"]
        obs_dim = int(model["a2c_network.actor_mlp.0.weight"].shape[1])
        hidden0 = int(model["a2c_network.actor_mlp.0.weight"].shape[0])
        hidden1 = int(model["a2c_network.actor_mlp.2.weight"].shape[0])
        hidden2 = int(model["a2c_network.actor_mlp.4.weight"].shape[0])
        act_dim = int(model["a2c_network.mu.weight"].shape[0])
        self.obs_dim = obs_dim
        self.stochastic = bool(stochastic)

        self.actor_mlp = nn.Sequential(
            nn.Linear(obs_dim, hidden0),
            nn.ELU(),
            nn.Linear(hidden0, hidden1),
            nn.ELU(),
            nn.Linear(hidden1, hidden2),
            nn.ELU(),
        )
        self.mu = nn.Linear(hidden2, act_dim)

        self.actor_mlp[0].weight.data.copy_(model["a2c_network.actor_mlp.0.weight"])
        self.actor_mlp[0].bias.data.copy_(model["a2c_network.actor_mlp.0.bias"])
        self.actor_mlp[2].weight.data.copy_(model["a2c_network.actor_mlp.2.weight"])
        self.actor_mlp[2].bias.data.copy_(model["a2c_network.actor_mlp.2.bias"])
        self.actor_mlp[4].weight.data.copy_(model["a2c_network.actor_mlp.4.weight"])
        self.actor_mlp[4].bias.data.copy_(model["a2c_network.actor_mlp.4.bias"])
        self.mu.weight.data.copy_(model["a2c_network.mu.weight"])
        self.mu.bias.data.copy_(model["a2c_network.mu.bias"])

        sigma_param = model.get("a2c_network.sigma")
        if sigma_param is None:
            self.register_buffer("logstd", torch.full((act_dim,), -2.0))
        else:
            self.register_buffer("logstd", sigma_param.float().view(-1))

        rms = checkpoint.get("running_mean_std")
        if rms is None:
            self.register_buffer("running_mean", torch.zeros(obs_dim))
            self.register_buffer("running_var", torch.ones(obs_dim))
        else:
            self.register_buffer("running_mean", rms["running_mean"].float())
            self.register_buffer("running_var", rms["running_var"].float())

        self.to(device)
        self.eval()

    @torch.no_grad()
    def forward(self, obs):
        if obs.shape[-1] > self.obs_dim:
            obs = obs[..., :self.obs_dim]
        elif obs.shape[-1] < self.obs_dim:
            raise ValueError(
                f"Observation dim {obs.shape[-1]} is smaller than checkpoint input {self.obs_dim}"
            )
        obs = (obs - self.running_mean) / torch.sqrt(self.running_var + 1e-5)
        obs = torch.clamp(obs, -5.0, 5.0)
        mu = self.mu(self.actor_mlp(obs))
        if self.stochastic:
            std = torch.exp(self.logstd).expand_as(mu)
            mu = mu + torch.randn_like(mu) * std
        return mu


class GLAActor(nn.Module):
    """Actor matching configs/train/gla/ppo.yaml.
    Reconstructs the GLA Network from `backbones/gla/a2c_network.py` and copies
    weights from a checkpoint. Architecture parameters are inferred from
    the state-dict shapes:
      base_dim       = actor_mlp.0.weight.shape[1]
      mlp_units      = [actor_mlp.0.weight.shape[0],
                        actor_mlp.2.weight.shape[0],
                        actor_mlp.4.weight.shape[0]]
      gla_hidden     = token_proj.weight.shape[0]
      token_dim      = token_proj.weight.shape[1]
      gla.num_heads  = inferred indirectly from gla.q_proj.weight (we just
                       reuse the default of 4 since key_dim=hidden*0.5=64,
                       and 64/4 = 16 head_k_dim is the standard config).
    """

    def __init__(self, checkpoint, device, history_length=16, stochastic=False,
                 pool="last", phys_aux=False):
        super().__init__()
        from backbones.gla.a2c_network import GLAA2CBuilder

        model = checkpoint["model"]
        base_dim = int(model["a2c_network.actor_mlp.0.weight"].shape[1])
        h0 = int(model["a2c_network.actor_mlp.0.weight"].shape[0])
        h1 = int(model["a2c_network.actor_mlp.2.weight"].shape[0])
        h2 = int(model["a2c_network.actor_mlp.4.weight"].shape[0])
        token_dim = int(model["a2c_network.token_proj.weight"].shape[1])
        gla_hidden = int(model["a2c_network.token_proj.weight"].shape[0])
        act_dim = int(model["a2c_network.mu.weight"].shape[0])

        # ---- PICA v2b: auto-detect aux head from state_dict ----
        # The presence of aux_head.* keys implies the checkpoint was trained
        # under physical_auxiliary, which means obs_dim = base + history + aux.
        # We honour an explicit `phys_aux` request as well so the caller can
        # force a build (e.g. for shape-mismatch debugging).
        aux_keys_present = any(
            k.startswith("a2c_network.aux_head.") for k in model
        )
        aux_enabled = bool(aux_keys_present or phys_aux)
        if aux_enabled and "a2c_network.aux_head.2.weight" in model:
            aux_pred_dim = int(model["a2c_network.aux_head.2.weight"].shape[0])
            aux_hidden   = int(model["a2c_network.aux_head.2.weight"].shape[1])
        elif aux_enabled:
            # Forced via --phys_aux but no aux_head in state_dict; use defaults
            # so the network exposes the right slot for the env's aux tail.
            aux_pred_dim = 3
            aux_hidden   = 64
        else:
            aux_pred_dim = 0
            aux_hidden   = 64
        # In v2b-init aux_target_dim == aux_pred_dim (no separate gate channel).
        aux_target_dim = aux_pred_dim if aux_enabled else 0

        self.base_dim = base_dim
        self.history_length = int(history_length)
        self.token_dim = token_dim
        self.aux_enabled = aux_enabled
        self.aux_pred_dim = aux_pred_dim
        self.aux_target_dim = aux_target_dim
        self.aux_hidden = aux_hidden
        self.aux_keys_present_in_ckpt = bool(aux_keys_present)
        self.obs_dim = (
            base_dim + self.history_length * token_dim + self.aux_target_dim
        )
        self.stochastic = bool(stochastic)

        params = {
            "separate": False,
            "mlp": {
                "units": [h0, h1, h2],
                "activation": "elu",
                "initializer": {"name": "default"},
                "d2rl": False,
                "norm_only_first_layer": False,
            },
            "space": {"continuous": {
                "mu_activation": "None",
                "sigma_activation": "None",
                "mu_init": {"name": "default"},
                "sigma_init": {"name": "const_initializer", "val": -2.0},
                "fixed_sigma": True,
            }},
            "gla": {
                "history_length": self.history_length,
                "token_dim": self.token_dim,
                "hidden_size": gla_hidden,
                "num_heads": 4,
                "expand_k": 0.5,
                "expand_v": 1.0,
                "mode": "chunk",
                "pool": str(pool).lower(),
            },
            # PICA v2b: build aux head exactly when checkpoint contains one,
            # so load_state_dict produces no unexpected keys. The head is
            # never read at inference because forward sets is_train=False.
            "phys_aux": {
                "enabled":     bool(aux_enabled),
                "pred_dim":    int(aux_pred_dim),
                "target_dim":  int(aux_target_dim),
                "hidden_size": int(aux_hidden),
            },
            "value_activation": "None",
            "normalization": None,
        }

        builder = GLAA2CBuilder()
        builder.load(params)
        self.net = builder.build(
            "a2c",
            actions_num=act_dim,
            input_shape=(self.obs_dim,),
            value_size=1,
            num_seqs=1,
        )

        # Strip the `a2c_network.` prefix from checkpoint keys before loading.
        ckpt_state = {
            k[len("a2c_network."):]: v
            for k, v in model.items()
            if k.startswith("a2c_network.")
        }
        missing, unexpected = self.net.load_state_dict(ckpt_state, strict=False)
        if missing:
            print(f"  [gla-actor] missing keys: {missing[:5]}{'...' if len(missing) > 5 else ''}")
        if unexpected:
            print(f"  [gla-actor] unexpected keys: {unexpected[:5]}{'...' if len(unexpected) > 5 else ''}")

        # Logstd buffer (sigma is loaded as part of the net; expose for sampling).
        sigma_param = model.get("a2c_network.sigma")
        if sigma_param is None:
            self.register_buffer("logstd", torch.full((act_dim,), -2.0))
        else:
            self.register_buffer("logstd", sigma_param.float().view(-1))

        rms = checkpoint.get("running_mean_std")
        if rms is None:
            self.register_buffer("running_mean", torch.zeros(self.obs_dim))
            self.register_buffer("running_var", torch.ones(self.obs_dim))
        else:
            self.register_buffer("running_mean", rms["running_mean"].float())
            self.register_buffer("running_var", rms["running_var"].float())

        self.to(device)
        self.eval()

    @torch.no_grad()
    def forward(self, obs):
        if obs.shape[-1] != self.obs_dim:
            current_history_aux = self.history_length * self.token_dim + self.aux_target_dim
            current_base_dim = obs.shape[-1] - current_history_aux
            pad_dim = self.base_dim - current_base_dim
            if 0 < pad_dim <= 8 and current_base_dim > 0:
                # Eval-only compatibility for older PICA checkpoints whose
                # base_obs had a few extra channels before the history block.
                # Insert zeros between base_obs and history/aux so temporal
                # tokens and aux targets remain aligned.
                base = obs[..., :current_base_dim]
                tail = obs[..., current_base_dim:]
                pad = torch.zeros(*obs.shape[:-1], pad_dim, device=obs.device, dtype=obs.dtype)
                obs = torch.cat([base, pad, tail], dim=-1)
            if obs.shape[-1] != self.obs_dim:
                raise ValueError(
                    f"Observation dim {obs.shape[-1]} != checkpoint obs_dim {self.obs_dim}"
                )
        obs_norm = (obs - self.running_mean) / torch.sqrt(self.running_var + 1e-5)
        obs_norm = torch.clamp(obs_norm, -5.0, 5.0)
        # PICA v2b: is_train=False short-circuits the aux head branch in
        # GLAA2CBuilder.Network.forward so no aux compute happens at eval.
        # Action selection therefore depends ONLY on the actor / GLA path,
        # which is identical to v1 / v2a behaviour.
        mu, sigma, _value, _states = self.net({"obs": obs_norm, "is_train": False})
        if self.stochastic:
            std = torch.exp(self.logstd).expand_as(mu)
            mu = mu + torch.randn_like(mu) * std
        return mu


def parse_args():
    parser = argparse.ArgumentParser(description="Evaluate a HandDrag PPO checkpoint")
    parser.add_argument("--config", default="configs/env/hand_config.yaml")
    parser.add_argument("--object_id", default="45661")
    parser.add_argument("--trajectory", default=None)
    parser.add_argument("--checkpoint", required=True)
    parser.add_argument("--checkpoint-kind", choices=("best", "latest"),
                        default="best")
    parser.add_argument("--target_joint_idx", type=int, default=None)
    parser.add_argument("--handle_link_name", default=None)
    parser.add_argument("--episodes", type=int, default=10)
    parser.add_argument("--max_episode_length", type=int, default=300)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--ema_alpha", type=float, default=1.0,
                        help="Eval action EMA alpha; 1 disables smoothing")
    parser.add_argument("--stochastic", action="store_true",
                        help="Sample actions from N(mu, exp(logstd)) instead "
                             "of using deterministic mu. Matches what the "
                             "training reward curve was actually computed on.")
    parser.add_argument("--n_settle_substeps", type=int, default=None,
                        help="Override task.n_settle_substeps (eval only). "
                             "Default in task is 4. Larger values give the "
                             "PD controller more time to stabilize the grasp "
                             "after each reset before the policy starts "
                             "perturbing the state.")
    parser.add_argument("--detach_arm_delay", type=int, default=0,
                        help="Number of post-reset steps during which the "
                             "detach gate is forcibly disarmed. The default "
                             "task arms detach the moment palm-handle "
                             "distance is <= 0.1, which means a saturated "
                             "first-step action can fire the -50 detach "
                             "penalty in one tick. Eval-only override.")
    parser.add_argument("--no-headless", action="store_true")
    parser.add_argument("--log_csv", default=None)
    parser.add_argument("--summary_json", default=None)
    # ---- OOD dynamics overrides (eval-only, training defaults preserved) ----
    parser.add_argument("--object_damping_scale", type=float, default=1.0,
                        help="Multiply the articulated-object DOF damping by "
                             "this factor at eval time. Default 1.0 (training "
                             "value 10.0). Larger values make the joint more "
                             "viscous.")
    parser.add_argument("--object_friction_scale", type=float, default=1.0,
                        help="Multiply the articulated-object rigid-shape "
                             "friction by this factor at eval time. Default "
                             "1.0 (training value 5.0). Affects hand <-> "
                             "object contact friction only; hand surface "
                             "friction is unchanged.")
    parser.add_argument("--gla_pool", choices=("last", "mean"), default="last",
                        help="GLA temporal pool used at eval. Must match the "
                             "value the checkpoint was trained with: pool=last "
                             "(default, matches configs/train/gla/ppo.yaml) or "
                             "pool=mean (for checkpoints trained from "
                             "configs/train/gla/ppo_pool_mean.yaml). The state dict "
                             "is identical between the two so this cannot be "
                             "auto-detected from weights alone.")
    parser.add_argument("--phys_aux", "--physical_auxiliary",
                        dest="phys_aux", type=int, default=None,
                        help="0/1: enable physical_auxiliary at eval time so "
                             "HandDragTask appends aux targets to obs and "
                             "GLAActor builds the aux head. When omitted "
                             "(default), it is auto-detected from the "
                             "checkpoint's state_dict (presence of "
                             "a2c_network.aux_head.* keys). Forcing 1 on a "
                             "non-aux checkpoint is a debug knob; forcing 0 "
                             "on an aux checkpoint will raise on load.")
    return parser.parse_known_args()


def apply_ood_dynamics_overrides(env, damping_scale, friction_scale):
    """Eval-only override of articulated-object joint damping and shape friction.
    Re-applies modified DOF properties and shape properties to every parallel
    articulated actor that was already created by HandObjectGym.load_envs().
    Hand DOF properties and hand contact friction are left untouched, and the
    drive_mode (DOF_MODE_NONE) is preserved.
    Returns the (final_damping, final_friction) actually read back from
    Isaac Gym, so the caller can verify the override took effect.
    """
    from isaacgym import gymapi  # noqa: F401  (must be after env init)
    if damping_scale == 1.0 and friction_scale == 1.0:
        return None, None

    # Joint damping (per-DOF, but currently set globally to 10.0 for object).
    if damping_scale != 1.0:
        new_damp = float(env.arti_obj_dof_props["damping"][0]) * damping_scale
        env.arti_obj_dof_props["damping"][:] = new_damp
        for i in range(env.num_envs):
            env.gym.set_actor_dof_properties(
                env.envs[i], env.arti_actors[i], env.arti_obj_dof_props,
            )
    # Verify by reading back env 0's DOF damping.
    if damping_scale != 1.0:
        ck_props = env.gym.get_actor_dof_properties(
            env.envs[0], env.arti_actors[0],
        )
        damp_after = float(ck_props["damping"][0])
    else:
        damp_after = float(env.arti_obj_dof_props["damping"][0])

    # Contact friction (per-shape).
    if friction_scale != 1.0:
        for i in range(env.num_envs):
            sp = env.gym.get_actor_rigid_shape_properties(
                env.envs[i], env.arti_actors[i],
            )
            for s in sp:
                s.friction = float(s.friction) * friction_scale
            env.gym.set_actor_rigid_shape_properties(
                env.envs[i], env.arti_actors[i], sp,
            )
        sp_after = env.gym.get_actor_rigid_shape_properties(
            env.envs[0], env.arti_actors[0],
        )
        fric_after = float(sp_after[0].friction) if len(sp_after) > 0 else None
    else:
        fric_after = 5.0

    return damp_after, fric_after


def resolve_checkpoint_path(checkpoint_arg, checkpoint_kind, run_name="HandDrag"):
    checkpoint_path = Path(checkpoint_arg).resolve()
    if checkpoint_path.is_file():
        return checkpoint_path
    if not checkpoint_path.is_dir():
        raise FileNotFoundError(f"Checkpoint not found: {checkpoint_arg}")

    candidates = sorted(
        glob.glob(str(checkpoint_path / "*.pth")),
        key=os.path.getmtime,
        reverse=True,
    )
    if not candidates:
        raise FileNotFoundError(f"No .pth checkpoints found in: {checkpoint_path}")

    if checkpoint_kind == "latest":
        return Path(candidates[0])

    preferred = checkpoint_path / f"{run_name}.pth"
    return preferred if preferred.exists() else Path(candidates[0])


def infer_include_handle_rot(checkpoint, trajectory):
    """Infer (handle_rot, prev_action_in_history) from a checkpoint."""
    if not trajectory:
        raise ValueError("Empty trajectory")
    state = checkpoint["model"]
    input_dim = int(state["a2c_network.actor_mlp.0.weight"].shape[1])
    is_gla_ckpt = _is_gla_checkpoint(state)

    n_arti_dofs = len(trajectory[0]["joint_positions"])
    palm_extra = 3 + 1
    base_with_rot = 51 + 51 + 3 + 4 + palm_extra + n_arti_dofs + n_arti_dofs
    base_without_rot = 51 + 51 + 3 + palm_extra + n_arti_dofs + n_arti_dofs
    history_flat = 16 * 51
    history_gla = 16 * 102

    if is_gla_ckpt:
        # GLA actor_mlp consumes only base_obs.
        if input_dim == base_with_rot:
            print(
                f"  [checkpoint] GLA ckpt: base_dim={input_dim}, "
                "handle_rot=True, prev_action_in_history=True"
            )
            return True, True
        if input_dim == base_with_rot + 3:
            print(
                f"  [checkpoint] legacy GLA ckpt: base_dim={input_dim}, "
                "handle_rot=True, prev_action_in_history=True, eval pads 3 base channels"
            )
            return True, True
        if input_dim == base_without_rot:
            print(
                f"  [checkpoint] GLA ckpt: base_dim={input_dim}, "
                "handle_rot=False, prev_action_in_history=True"
            )
            return False, True
        if input_dim == base_without_rot + 3:
            print(
                f"  [checkpoint] legacy GLA ckpt: base_dim={input_dim}, "
                "handle_rot=False, prev_action_in_history=True, eval pads 3 base channels"
            )
            return False, True
        raise ValueError(
            f"GLA ckpt base_dim {input_dim} does not match "
            f"base_with_rot={base_with_rot} or base_without_rot={base_without_rot}"
        )

    if input_dim in (base_with_rot, base_with_rot + history_flat):
        print(f"  [checkpoint] flat-MLP obs_dim={input_dim} -> handle_rot=True, prev_action=False")
        return True, False
    if input_dim in (base_without_rot, base_without_rot + history_flat):
        print(f"  [checkpoint] flat-MLP obs_dim={input_dim} -> handle_rot=False, prev_action=False")
        return False, False
    if input_dim in (base_with_rot + history_gla, base_without_rot + history_gla):
        # Defensive: unrecognised non-GLA but with 102-D history -- assume
        # prev_action present even though we don't see GLA keys.
        with_rot = (input_dim == base_with_rot + history_gla)
        print(
            f"  [checkpoint] flat-history-with-prev_action obs_dim={input_dim} -> "
            f"handle_rot={with_rot}, prev_action=True"
        )
        return with_rot, True
    raise ValueError(
        "Checkpoint input dim does not match known observation layouts: "
        f"input_dim={input_dim}, base_with_rot={base_with_rot}, "
        f"base_without_rot={base_without_rot}, history_flat={history_flat}, "
        f"history_gla={history_gla}"
    )


def load_config(args):
    with open(PROJECT_ROOT / args.config) as f:
        cfg = yaml.safe_load(f)

    cfg["HEADLESS"] = not args.no_headless
    cfg["num_envs"] = 1
    cfg["cam"]["use_cam"] = False
    cfg["asset"]["arti_gapartnet_ids"] = [int(args.object_id)]
    return cfg


def trajectory_path(args):
    if args.trajectory:
        path = Path(args.trajectory)
        print(f"  [trajectory] using (--trajectory): {path}")
        return path
    manifest_path = Path(os.environ.get(
        "HAND_DRAG_MANIFEST",
        str(PROJECT_ROOT / "data" / "manifest.csv"),
    ))
    if manifest_path.exists():
        import csv
        with manifest_path.open(newline="") as f:
            for row in csv.DictReader(f):
                if (
                    row.get("object_id") == str(args.object_id)
                    and row.get("enabled", "1").strip() == "1"
                ):
                    path = Path(row["trajectory"])
                    print(f"  [trajectory] using (manifest:{manifest_path}): {path}")
                    return path
    if os.environ.get("HAND_DRAG_ALLOW_DEFAULT_TRAJECTORY") == "1":
        path = PROJECT_ROOT / "output" / "hand_drag" / args.object_id / "trajectory.json"
        print(f"  [trajectory] using (legacy output/hand_drag fallback): {path}")
        return path
    raise FileNotFoundError(
        f"No canonical trajectory for object_id={args.object_id}. "
        "Pass --trajectory or set HAND_DRAG_MANIFEST."
    )


def eval_step(task: HandDragTask, action):
    """Single-env eval step that mirrors ``task.step()`` order.
    rl_games' player goes through ``task.step()``, which runs
    ``pre_physics_step -> simulate -> compute_reward -> reset_idx (if done)
    -> compute_observations``.
    We deliberately skip the internal ``reset_idx`` here so the metric
    capture in ``metric_row`` (which reads ``task.dof_pos`` directly) sees
    the genuine episode-terminal state instead of a freshly reset one.
    The outer evaluation loop calls ``task.reset()`` between episodes, so
    inter-episode state is still reset cleanly via the public reset path.
    The ordering ``compute_reward -> compute_observations`` matches
    ``task.step()`` exactly. For single-env non-done steps it is
    functionally equivalent to the reverse order (compute_reward only
    mutates reward / done buffers; compute_observations only reads
    PhysX state), but matching the order keeps any future state
    coupling consistent with the training-time path.
    """
    task.pre_physics_step(action)
    task.gym.simulate(task.sim)
    task.gym.fetch_results(task.sim, True)
    task._render_viewer()
    reward, done = task.compute_reward()
    task.compute_observations()
    return task.obs_buf, reward, done


def metric_row(task, episode, step, reward, done):
    cur_joint = task.dof_pos[0, N_HAND_DOFS + task.target_joint_idx, 0]
    progress = (cur_joint - task.task_start_joint) / task.task_progress_denom
    action_abs_max = task.actions[0].abs().max()
    action_l2 = torch.linalg.vector_norm(task.actions[0])

    return {
        "episode": int(episode),
        "step": int(step),
        "target_joint": float(cur_joint.item()),
        "normalized_progress": float(progress.item()),
        "palm_to_handle_dist": float(task.palm_to_handle_dist[0].item()),
        "reward": float(reward[0].item()),
        "done": int(bool(done[0].item())),
        "success": int(bool(task._success_flag[0].item())),
        "action_abs_max": float(action_abs_max.item()),
        "action_l2": float(action_l2.item()),
    }


def summarize_episode(rows):
    final = rows[-1]
    return {
        "episode": final["episode"],
        "steps": len(rows),
        "return": sum(row["reward"] for row in rows),
        "success": int(any(row["success"] for row in rows)),
        "final_target_joint": final["target_joint"],
        "normalized_progress": final["normalized_progress"],
        "mean_palm_handle_dist": sum(row["palm_to_handle_dist"] for row in rows) / len(rows),
        "mean_action_l2": sum(row["action_l2"] for row in rows) / len(rows),
        "mean_action_abs_max": sum(row["action_abs_max"] for row in rows) / len(rows),
    }


def mean(items, key):
    return sum(float(item[key]) for item in items) / max(1, len(items))


def main():
    args, gym_args = parse_args()
    sys.argv = [sys.argv[0]] + gym_args
    torch.manual_seed(args.seed)

    ckpt_path = resolve_checkpoint_path(args.checkpoint, args.checkpoint_kind)
    checkpoint = torch.load(ckpt_path, map_location="cpu")

    cfg = load_config(args)
    traj_path = trajectory_path(args)
    if not traj_path.exists():
        raise FileNotFoundError(f"Trajectory not found: {traj_path}")
    with open(traj_path) as f:
        trajectory = json.load(f)
    include_handle_rot, include_prev_action_in_history = infer_include_handle_rot(
        checkpoint, trajectory,
    )
    is_gla = _is_gla_checkpoint(checkpoint["model"])

    # ---- PICA v2b: decide whether the env should append aux targets to obs.
    # Auto-detect from the checkpoint's state_dict (presence of aux_head.*)
    # and let an explicit --phys_aux flag override. Only meaningful for GLA
    # checkpoints; the flat-MLP actor has no aux head pathway.
    aux_keys_in_ckpt = any(
        k.startswith("a2c_network.aux_head.") for k in checkpoint["model"]
    )
    if args.phys_aux is None:
        eval_phys_aux = bool(aux_keys_in_ckpt)
    else:
        eval_phys_aux = bool(int(args.phys_aux))
    if eval_phys_aux and not is_gla:
        print(
            "  [warn] --phys_aux requested but checkpoint is flat-MLP "
            "(no aux head pathway). Disabling aux targets in env."
        )
        eval_phys_aux = False

    eval_phys_aux_cfg = None
    if eval_phys_aux:
        # Infer aux_pred_dim from the checkpoint so the env emits the right
        # number of aux-tail channels. The aux_head's last linear layer's
        # output dim is the regression count; for v2b that is 3 and for v2c
        # that is 4. If the checkpoint has no aux_head (forced --phys_aux 1
        # on a non-aux ckpt), default to v2b's 3 channels.
        ckpt_aux_pred_dim = 0
        if "a2c_network.aux_head.2.weight" in checkpoint["model"]:
            ckpt_aux_pred_dim = int(
                checkpoint["model"]["a2c_network.aux_head.2.weight"].shape[0]
            )

        if ckpt_aux_pred_dim == 4:
            # v2c causal_horizon mode. K is not stored in the checkpoint;
            # default 5 matches the recommended training config. The actor
            # never reads aux targets, so a different K only changes raw
            # values, not behaviour.
            eval_phys_aux_cfg = {
                "enabled": True,
                "mode":    "causal_horizon",
                "horizon": 5,
                "targets": {
                    "q_response_K":    {"enabled": True},
                    "max_dist_K":      {"enabled": True},
                    "detach_proxy_K":  {"enabled": True},
                    "tracking_stress": {"enabled": True},
                },
                "gating": {"enabled": False, "d_valid": 0.10, "sharpness": 80.0},
                "warmup": {"enabled": False, "max_weight": 0.0},
            }
        else:
            # v2b "current" mode (3 targets) or forced-on with no head.
            eval_phys_aux_cfg = {
                "enabled": True,
                "mode":    "current",
                "targets": {
                    "dq_obj":          {"enabled": True},
                    "slip_proxy":      {"enabled": True},
                    "tracking_stress": {"enabled": True},
                },
                "gating": {"enabled": False, "d_valid": 0.10, "sharpness": 80.0},
                "warmup": {"enabled": False, "max_weight": 0.0},
            }

    env = HandObjectGym(cfg)
    env.get_gapartnet_anno()
    env.run_steps(50, refresh_obs=True)
    handle_link_name = resolve_handle_link_name(
        env,
        args.handle_link_name,
        target_joint_idx=args.target_joint_idx,
        trajectory_path=str(traj_path),
        env_config=cfg,
        object_id=args.object_id,
    )

    # ---- Apply OOD dynamics overrides BEFORE the eval loop and BEFORE the
    # task is constructed. The task only reads object DOF state during the
    # episode, not asset properties, so it is safe to swap props here.
    damp_after, fric_after = apply_ood_dynamics_overrides(
        env,
        damping_scale=float(args.object_damping_scale),
        friction_scale=float(args.object_friction_scale),
    )
    if args.object_damping_scale != 1.0 or args.object_friction_scale != 1.0:
        print(
            f"  [ood] object damping x{args.object_damping_scale} "
            f"-> {damp_after} (verified)"
        )
        print(
            f"  [ood] object friction x{args.object_friction_scale} "
            f"-> {fric_after} (verified)"
        )

    task = HandDragTask(
        env,
        trajectory_path=str(traj_path),
        target_joint_idx=args.target_joint_idx,
        handle_link_name=handle_link_name,
        include_handle_rot=include_handle_rot,
        is_eval_mode=True,
        epoch_log_path=None,
        include_prev_action_in_history=include_prev_action_in_history,
        physical_auxiliary=eval_phys_aux_cfg,
    )
    task.max_episode_length = int(args.max_episode_length)
    task.eval_action_ema_alpha = float(args.ema_alpha)
    if args.n_settle_substeps is not None:
        task.n_settle_substeps = int(args.n_settle_substeps)
        print(f"  [override] n_settle_substeps = {task.n_settle_substeps}")
    if args.detach_arm_delay > 0:
        print(f"  [override] detach_arm_delay = {args.detach_arm_delay} steps")
    if is_gla:
        actor = GLAActor(
            checkpoint,
            task.device,
            history_length=task.history_len,
            stochastic=args.stochastic,
            pool=args.gla_pool,
            phys_aux=eval_phys_aux,
        )
        print(f"  [actor] type = GLA  pool={args.gla_pool}")
    else:
        actor = RLGamesActor(checkpoint, task.device, stochastic=args.stochastic)
        print("  [actor] type = flat-MLP")
    print(f"  [actor] mode = {'stochastic' if args.stochastic else 'deterministic'}")

    # ---- PICA v2b: diagnostic startup banner for shape / aux alignment ----
    # Helps catch the train/eval obs-dim mismatch class of bugs at a glance.
    ckpt_obs_dim_inferred = (
        actor.obs_dim if is_gla else getattr(actor, "obs_dim", None)
    )
    aux_size = getattr(actor, "aux_target_dim", 0) if is_gla else 0
    actor_main_obs_dim = (
        getattr(actor, "base_dim", None) if is_gla
        else getattr(actor, "obs_dim", None)
    )
    print()
    print("  [eval-diagnostic]")
    print(f"    checkpoint                = {ckpt_path}")
    print(f"    aux_keys_in_ckpt          = {aux_keys_in_ckpt}")
    print(f"    --phys_aux requested      = {args.phys_aux}")
    print(f"    physical_auxiliary.enabled= {eval_phys_aux}")
    print(f"    inferred ckpt obs_dim     = {ckpt_obs_dim_inferred}")
    print(f"    env obs_dim               = {task.obs_dim}")
    print(f"    aux_size (sliced off)     = {aux_size}")
    print(f"    actor_main_obs_dim        = {actor_main_obs_dim}")
    print(f"    network type              = {'GLA' if is_gla else 'flat-MLP'}")
    print(f"    actor / algo type         = {type(actor).__name__}")
    if is_gla and ckpt_obs_dim_inferred != task.obs_dim:
        print(
            f"  [eval-diagnostic][WARN] obs_dim mismatch: ckpt expects "
            f"{ckpt_obs_dim_inferred} but env emits {task.obs_dim}. "
            "Verify --phys_aux flag and physical_auxiliary YAML config."
        )
    print()

    all_rows = []
    episodes = []
    try:
        for episode in range(args.episodes):
            obs = task.reset()
            rows = []
            for step in range(args.max_episode_length):
                if step < args.detach_arm_delay:
                    task.detach_armed_buf.zero_()
                with torch.no_grad():
                    action = actor(obs).clamp(-1.0, 1.0)
                obs, reward, done = eval_step(task, action)
                row = metric_row(task, episode, step, reward, done)
                rows.append(row)
                all_rows.append(row)
                if bool(done[0].item()):
                    break
            episodes.append(summarize_episode(rows))

        summary = {
            "object_id": str(args.object_id),
            "checkpoint": str(ckpt_path),
            "trajectory": str(traj_path),
            "target_joint_idx": int(task.target_joint_idx),
            "handle_link_name": handle_link_name,
            "episodes": int(args.episodes),
            "success_rate": mean(episodes, "success"),
            "return_mean": mean(episodes, "return"),
            "steps_mean": mean(episodes, "steps"),
            "final_target_joint_mean": mean(episodes, "final_target_joint"),
            "normalized_progress_mean": mean(episodes, "normalized_progress"),
            "mean_palm_handle_dist": mean(episodes, "mean_palm_handle_dist"),
            "mean_action_l2": mean(episodes, "mean_action_l2"),
            "mean_action_abs_max": mean(episodes, "mean_action_abs_max"),
            "stochastic": bool(args.stochastic),
            "episode_metrics": episodes,
            "object_damping_scale": float(args.object_damping_scale),
            "object_friction_scale": float(args.object_friction_scale),
            "object_damping_actual": damp_after,
            "object_friction_actual": fric_after,
        }

        if args.log_csv:
            out = Path(args.log_csv)
            out.parent.mkdir(parents=True, exist_ok=True)
            with open(out, "w", newline="") as f:
                writer = csv.DictWriter(f, fieldnames=list(all_rows[0].keys()))
                writer.writeheader()
                writer.writerows(all_rows)

        if args.summary_json:
            out = Path(args.summary_json)
            out.parent.mkdir(parents=True, exist_ok=True)
            with open(out, "w") as f:
                json.dump(summary, f, indent=2)

        print("\nPPO checkpoint evaluation")
        print(f"  checkpoint: {ckpt_path}")
        print(f"  object id: {args.object_id}")
        print(f"  target joint idx: {task.target_joint_idx}")
        print(f"  handle link: {handle_link_name}")
        print(f"  episodes: {args.episodes}")
        print(f"  success rate: {summary['success_rate']:.3f}")
        print(f"  return mean: {summary['return_mean']:.3f}")
        print(f"  steps mean: {summary['steps_mean']:.1f}")
        print(f"  final target joint mean: {summary['final_target_joint_mean']:.6f}")
        print(f"  normalized progress mean: {summary['normalized_progress_mean']:.3f}")
        print(f"  mean palm-handle dist: {summary['mean_palm_handle_dist']:.4f}")
        print(f"  mean action l2: {summary['mean_action_l2']:.3f}")
        if args.log_csv:
            print(f"  wrote metrics: {args.log_csv}")
        if args.summary_json:
            print(f"  wrote summary: {args.summary_json}")
    finally:
        env.clean_up()


if __name__ == "__main__":
    main()