scripts/act/eval_task_e_act.py

"""Rollout evaluation for the Task-E ACT policy checkpoint."""

import argparse
import os
import sys
import time
from datetime import datetime

from isaaclab.app import AppLauncher


parser = argparse.ArgumentParser(description="Evaluate ACT checkpoint on ATEC Task E.")
parser.add_argument(
    "--checkpoint",
    type=str,
    default="runs/act-task-e-rgb-100demos-seed1/checkpoints/best_loss.pt",
    help="ACT checkpoint path.",
)
parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper")
parser.add_argument("--episodes", type=int, default=3)
parser.add_argument("--max_steps", type=int, default=1500)
parser.add_argument("--video_path", type=str, default=None, help="Optional MP4 output path for episode 1.")
parser.add_argument("--video_interval", type=int, default=2, help="Record every N env steps.")
parser.add_argument("--video_fps", type=int, default=25)
parser.add_argument("--seed", type=int, default=None)
parser.add_argument("--disable_fabric", action="store_true", default=False)
parser.add_argument("--debug", action="store_true", default=False)
parser.add_argument(
    "--solution_module",
    type=str,
    default="solution_act",
    help="Module under demo/ that provides AlgSolution, e.g. solution_act or 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__), "..", ".."))
checkpoint = os.path.abspath(args_cli.checkpoint)
os.environ["ATEC_ACT_POLICY_PATH"] = checkpoint

app_launcher = AppLauncher(args_cli)
simulation_app = app_launcher.app

import gymnasium as gym  # noqa: E402
import torch  # noqa: E402

from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent  # noqa: E402
from isaaclab_tasks.utils import parse_env_cfg  # noqa: E402

import atec_rl_lab.tasks  # noqa: F401, E402

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)
from scripts.act.task_e.collector import basket_status_lines  # noqa: E402
import importlib  # noqa: E402

AlgSolution = importlib.import_module(args_cli.solution_module).AlgSolution


def _frame_from_obs(obs) -> object:
    rgb = obs["image"]["video_rgb"]
    if isinstance(rgb, torch.Tensor):
        frame = rgb[0].detach().cpu()
        if frame.ndim == 3 and frame.shape[0] in (3, 4):
            frame = frame.permute(1, 2, 0)
        if frame.shape[-1] == 4:
            frame = frame[..., :3]
        if frame.dtype != torch.uint8:
            frame = (frame.float() * 255.0).clamp(0, 255).to(torch.uint8)
        return frame.numpy()
    return rgb[0]


def _resolve_video_path() -> str | None:
    if args_cli.video_path is None:
        return None
    if args_cli.video_path:
        return os.path.abspath(args_cli.video_path)
    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    return os.path.join(repo_root, "logs", "videos", "task_e_act_eval", f"eval_{stamp}.mp4")


def evaluate() -> list[dict[str, float]]:
    if not os.path.exists(checkpoint):
        raise FileNotFoundError(f"Checkpoint not found: {checkpoint}")

    env_cfg = parse_env_cfg(
        args_cli.task,
        device=args_cli.device,
        num_envs=1,
        use_fabric=not args_cli.disable_fabric,
    )
    if args_cli.seed is not None:
        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)

    policy = AlgSolution()
    video_path = _resolve_video_path()
    writer = None
    if video_path is not None:
        import imageio.v2 as imageio

        os.makedirs(os.path.dirname(video_path), exist_ok=True)
        writer = imageio.get_writer(video_path, fps=args_cli.video_fps, quality=7)
        print(f"[INFO] Recording episode 1 video to: {video_path}")

    results = []
    try:
        for episode in range(args_cli.episodes):
            reset_kwargs = {"seed": args_cli.seed + episode} if args_cli.seed is not None else {}
            obs, _ = env.reset(**reset_kwargs)
            policy.reset_episode()
            total_reward = 0.0
            elapsed_time = 0.0
            steps = 0
            done = False
            start_wall = time.time()
            if writer is not None and episode == 0:
                writer.append_data(_frame_from_obs(obs))

            while simulation_app.is_running() and steps < args_cli.max_steps:
                with torch.inference_mode():
                    resp = policy.predicts(obs, total_reward)
                    if resp["giveup"]:
                        break
                    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
                if isinstance(info, dict) and "Elapsed_Time" in info:
                    elapsed = info["Elapsed_Time"]
                    elapsed_time = elapsed.item() if hasattr(elapsed, "item") else float(elapsed)
                else:
                    elapsed_time += env.unwrapped.step_dt

                done = bool(terminated.item() or truncated.item())
                steps += 1
                if writer is not None and episode == 0 and steps % max(1, args_cli.video_interval) == 0:
                    writer.append_data(_frame_from_obs(obs))
                if args_cli.debug and steps % 100 == 0:
                    print(f"[DEBUG] episode={episode + 1} step={steps} score={total_reward:.2f}")
                if done:
                    break

            result = {
                "episode": episode + 1,
                "score": float(total_reward),
                "elapsed_time": float(elapsed_time),
                "steps": float(steps),
                "done": float(done),
                "wall_time": time.time() - start_wall,
            }
            results.append(result)
            try:
                for line in basket_status_lines(env, [1, 2, 3]):
                    print(f"[BASKET] episode={episode + 1} {line}")
            except Exception as exc:
                if args_cli.debug:
                    print(f"[DEBUG] basket status unavailable: {exc}")
            print(
                "[RESULT] "
                f"episode={result['episode']:.0f} "
                f"score={result['score']:.2f} "
                f"elapsed_time={result['elapsed_time']:.2f} "
                f"steps={result['steps']:.0f} "
                f"done={bool(result['done'])} "
                f"wall_time={result['wall_time']:.1f}s"
            )
    finally:
        if writer is not None:
            writer.close()
        env.close()

    return results


if __name__ == "__main__":
    try:
        results = evaluate()
        if results:
            scores = torch.tensor([r["score"] for r in results], dtype=torch.float32)
            print(f"[SUMMARY] episodes={len(results)} mean_score={scores.mean().item():.2f} best_score={scores.max().item():.2f}")
    finally:
        simulation_app.close()