debug/debug_puzzle.py

#!/usr/bin/env python3
"""Eval-stack oracle replay for OGBench Puzzle.

This script runs the same stable_worldmodel.World evaluation stack used by
eval_puzzle.py, including dataset goal construction, static goal-info
injection, callables, video writing, and success accounting. The only
difference is the policy: instead of a world model planner, it replays the
ground-truth dataset action at each environment step.
"""

from __future__ import annotations

import faulthandler
import json
import os
import sys
from pathlib import Path
from typing import Any

os.environ.setdefault("MUJOCO_GL", "egl")

ROOT_DIR = Path(__file__).resolve().parents[1]
if str(ROOT_DIR) not in sys.path:
    sys.path.insert(0, str(ROOT_DIR))

import hydra
import numpy as np
import stable_worldmodel as swm
import torch
from omegaconf import DictConfig, ListConfig, OmegaConf, open_dict

from eval import (
    _resolve_safe_row_limit,
    _resolve_world_env_name,
    evaluate_from_dataset_with_progress,
    get_dataset,
    get_episodes_length,
)


class DatasetActionReplayPolicy:
    """Policy that returns preloaded dataset actions one eval step at a time."""

    def __init__(self, actions: np.ndarray):
        actions = np.asarray(actions, dtype=np.float32)
        if actions.ndim != 3:
            raise ValueError(f"actions must have shape (num_envs, steps, action_dim), got {actions.shape}")
        self.actions = actions
        self.step_idx = 0

    def reset(self) -> None:
        self.step_idx = 0

    def get_action(self, infos: dict[str, Any]):
        action_idx = min(self.step_idx, self.actions.shape[1] - 1)
        actions = self.actions[:, action_idx]
        self.step_idx += 1
        return actions


def _to_numpy(value: Any) -> np.ndarray:
    if torch.is_tensor(value):
        return value.detach().cpu().numpy()
    return np.asarray(value)


def _jsonify(value: Any) -> Any:
    if isinstance(value, dict):
        return {str(k): _jsonify(v) for k, v in value.items()}
    if isinstance(value, (list, tuple)):
        return [_jsonify(v) for v in value]
    if isinstance(value, np.ndarray):
        return value.tolist()
    if isinstance(value, np.generic):
        return value.item()
    if torch.is_tensor(value):
        return value.detach().cpu().tolist()
    return value


def _debug_node(cfg: DictConfig):
    node = cfg.get("debug", {})
    return {} if node is None else node


def _debug_get(cfg: DictConfig, key: str, default: Any) -> Any:
    node = _debug_node(cfg)
    if isinstance(node, DictConfig):
        return node.get(key, default)
    if isinstance(node, dict):
        return node.get(key, default)
    return default


def _parse_row_indices(value: Any) -> list[int]:
    if value is None:
        return []
    if isinstance(value, (list, tuple, ListConfig)):
        return [int(v) for v in value]

    text = str(value).strip()
    if not text:
        return []
    if text.startswith("[") and text.endswith("]"):
        text = text[1:-1]
    return [int(part.strip()) for part in text.split(",") if part.strip()]


def _as_bool(value: Any, default: bool) -> bool:
    if value is None:
        return default
    if isinstance(value, bool):
        return value
    text = str(value).strip().lower()
    if text in {"1", "true", "yes", "y", "on"}:
        return True
    if text in {"0", "false", "no", "n", "off"}:
        return False
    return default


def _dataset_columns(dataset) -> tuple[str, np.ndarray, np.ndarray]:
    ep_key = "episode_idx" if "episode_idx" in dataset.column_names else "ep_idx"
    episode_idx = _to_numpy(dataset.get_col_data(ep_key)).reshape(-1)
    step_idx = _to_numpy(dataset.get_col_data("step_idx")).reshape(-1)
    if len(episode_idx) != len(step_idx):
        raise ValueError(f"len({ep_key})={len(episode_idx)} but len(step_idx)={len(step_idx)}")
    return ep_key, episode_idx, step_idx


def _select_rows(dataset, cfg: DictConfig) -> tuple[np.ndarray, np.ndarray, np.ndarray, dict[str, Any]]:
    ep_key, episode_idx_col, step_idx_col = _dataset_columns(dataset)
    safe_row_limit, row_counts = _resolve_safe_row_limit(dataset, [ep_key, "step_idx"])
    episode_idx_col = episode_idx_col[:safe_row_limit]
    step_idx_col = step_idx_col[:safe_row_limit]

    ep_indices, _ = np.unique(episode_idx_col, return_index=True)
    episode_len = get_episodes_length(dataset, ep_indices)
    max_start_idx_dict = {
        int(ep_id): int(episode_len[i] - int(cfg.eval.goal_offset_steps) - 1)
        for i, ep_id in enumerate(ep_indices)
    }

    require_budget_actions = _as_bool(_debug_get(cfg, "require_eval_budget_actions", True), True)
    if require_budget_actions:
        budget_max_start = {
            int(ep_id): int(episode_len[i] - int(cfg.eval.eval_budget) - 1)
            for i, ep_id in enumerate(ep_indices)
        }
        max_start_idx_dict = {
            ep_id: min(max_start_idx_dict[ep_id], budget_max_start[ep_id])
            for ep_id in max_start_idx_dict
        }

    max_start_per_row = np.array(
        [max_start_idx_dict.get(int(ep_id), -1) for ep_id in episode_idx_col],
        dtype=np.int64,
    )
    valid_mask = step_idx_col <= max_start_per_row
    valid_indices = np.nonzero(valid_mask)[0].astype(np.int64)

    explicit_rows = _parse_row_indices(_debug_get(cfg, "start_indices", ""))
    preferred_candidate_groups: list[np.ndarray] | None = None
    if explicit_rows:
        candidate_indices = np.asarray(explicit_rows, dtype=np.int64)
        bad = candidate_indices[(candidate_indices < 0) | (candidate_indices >= safe_row_limit)]
        if len(bad):
            raise ValueError(f"Explicit debug.start_indices outside dataset bounds: {bad.tolist()}")
        not_valid = candidate_indices[~valid_mask[candidate_indices]]
        if len(not_valid):
            raise ValueError(
                "Explicit debug.start_indices do not have enough future context "
                f"(goal_offset/eval_budget): {not_valid.tolist()}"
            )
        num_eval = len(candidate_indices)
    else:
        num_eval = int(cfg.eval.num_eval)
        candidate_indices = valid_indices

        prefer_button_change = _as_bool(_debug_get(cfg, "prefer_button_change", True), True)
        button_key = str(_debug_get(cfg, "button_key", "button_states"))
        if prefer_button_change and button_key in dataset.column_names:
            buttons = _to_numpy(dataset.get_col_data(button_key))[:safe_row_limit]
            buttons = buttons.reshape(buttons.shape[0], -1)
            goal_rows = candidate_indices + int(cfg.eval.goal_offset_steps)
            in_bounds = goal_rows < len(buttons)
            candidate_indices = candidate_indices[in_bounds]
            goal_rows = goal_rows[in_bounds]
            changed_mask = np.any(buttons[goal_rows] != buttons[candidate_indices], axis=1)
            changed = candidate_indices[changed_mask]
            unchanged = candidate_indices[~changed_mask]
            candidate_indices = np.concatenate([changed, unchanged])
            if len(changed):
                preferred_candidate_groups = [changed, unchanged]

    if len(candidate_indices) < num_eval:
        raise ValueError(f"Not enough valid oracle starts: requested {num_eval}, found {len(candidate_indices)}")

    rng = np.random.default_rng(int(cfg.seed))
    if explicit_rows:
        ordered_candidates = candidate_indices
    elif preferred_candidate_groups is not None:
        ordered_candidates = np.concatenate(
            [rng.permutation(group) for group in preferred_candidate_groups if len(group)]
        )
    else:
        ordered_candidates = rng.permutation(candidate_indices)

    selected_rows = ordered_candidates[:num_eval].astype(np.int64, copy=False)
    eval_episodes = episode_idx_col[selected_rows].astype(np.int64)
    eval_start_idx = step_idx_col[selected_rows].astype(np.int64)

    info = {
        "safe_row_limit": int(safe_row_limit),
        "row_counts": {str(k): int(v) for k, v in row_counts.items()},
        "valid_start_count": int(len(valid_indices)),
        "explicit_start_indices": [int(v) for v in explicit_rows],
        "require_eval_budget_actions": bool(require_budget_actions),
    }
    return selected_rows, eval_episodes, eval_start_idx, info


def _resolve_action_row(
    episode_idx_col: np.ndarray,
    step_idx_col: np.ndarray,
    ep_id: int,
    step: int,
    expected_row: int,
    lookup: dict[tuple[int, int], int] | None,
) -> tuple[int, dict[tuple[int, int], int] | None]:
    if (
        0 <= expected_row < len(episode_idx_col)
        and int(episode_idx_col[expected_row]) == ep_id
        and int(step_idx_col[expected_row]) == step
    ):
        return int(expected_row), lookup

    if lookup is None:
        lookup = {}
        for row, (row_ep, row_step) in enumerate(zip(episode_idx_col, step_idx_col)):
            lookup.setdefault((int(row_ep), int(row_step)), int(row))

    key = (int(ep_id), int(step))
    if key not in lookup:
        raise KeyError(f"Could not find dataset row for episode={ep_id}, step={step}")
    return int(lookup[key]), lookup


def _build_oracle_actions(
    dataset,
    selected_rows: np.ndarray,
    eval_episodes: np.ndarray,
    eval_start_idx: np.ndarray,
    eval_budget: int,
    action_key: str,
) -> tuple[np.ndarray, np.ndarray]:
    _, episode_idx_col, step_idx_col = _dataset_columns(dataset)
    actions_col = _to_numpy(dataset.get_col_data(action_key))
    if actions_col.ndim == 1:
        actions_col = actions_col.reshape(-1, 1)

    action_dim = int(actions_col.shape[-1])
    actions = np.empty((len(selected_rows), eval_budget, action_dim), dtype=np.float32)
    action_rows = np.empty((len(selected_rows), eval_budget), dtype=np.int64)

    lookup = None
    for env_idx, row in enumerate(selected_rows.tolist()):
        ep_id = int(eval_episodes[env_idx])
        start_step = int(eval_start_idx[env_idx])
        for t in range(eval_budget):
            action_row, lookup = _resolve_action_row(
                episode_idx_col=episode_idx_col,
                step_idx_col=step_idx_col,
                ep_id=ep_id,
                step=start_step + t,
                expected_row=int(row) + t,
                lookup=lookup,
            )
            actions[env_idx, t] = actions_col[action_row].astype(np.float32, copy=False)
            action_rows[env_idx, t] = action_row

    return actions, action_rows


def _button_summary(dataset, selected_rows: np.ndarray, cfg: DictConfig) -> dict[str, Any]:
    button_key = str(_debug_get(cfg, "button_key", "button_states"))
    if button_key not in dataset.column_names:
        return {"has_button_states": False}

    buttons = _to_numpy(dataset.get_col_data(button_key))
    buttons = buttons.reshape(buttons.shape[0], -1)
    goal_rows = selected_rows + int(cfg.eval.goal_offset_steps)
    valid = goal_rows < len(buttons)
    if not np.all(valid):
        goal_rows = goal_rows[valid]
        selected_rows = selected_rows[valid]
    start_buttons = buttons[selected_rows]
    goal_buttons = buttons[goal_rows]
    changed = np.any(start_buttons != goal_buttons, axis=1)
    return {
        "has_button_states": True,
        "button_key": button_key,
        "button_changed_to_goal_count": int(np.count_nonzero(changed)),
        "button_changed_to_goal_fraction": float(np.mean(changed)) if len(changed) else 0.0,
        "button_start": start_buttons.tolist(),
        "button_goal": goal_buttons.tolist(),
    }


def _default_out_dir(cfg: DictConfig) -> Path:
    debug_out = _debug_get(cfg, "out_dir", "")
    if debug_out:
        return Path(os.path.expandvars(str(debug_out))).expanduser()
    cache_dir = Path(str(cfg.get("cache_dir", "") or swm.data.utils.get_cache_dir()))
    return cache_dir / "debug_puzzle_eval_stack"


@hydra.main(version_base=None, config_path="../config/eval", config_name="puzzle")
def main(cfg: DictConfig):
    faulthandler.enable(all_threads=True)

    with open_dict(cfg):
        if "cache_dir" not in cfg:
            cfg.cache_dir = ""
        cfg.world.env_name = _resolve_world_env_name(str(cfg.world.env_name))
        cfg.world.max_episode_steps = 2 * int(cfg.eval.eval_budget)

    dataset = get_dataset(cfg, cfg.eval.dataset_name)
    selected_rows, eval_episodes, eval_start_idx, selection_info = _select_rows(dataset, cfg)

    with open_dict(cfg):
        cfg.eval.num_eval = int(len(selected_rows))
        cfg.world.num_envs = int(len(selected_rows))

    action_key = str(_debug_get(cfg, "action_key", "action"))
    if action_key not in dataset.column_names:
        raise KeyError(f"Action key '{action_key}' not found. Available columns: {dataset.column_names}")
    oracle_actions, action_rows = _build_oracle_actions(
        dataset=dataset,
        selected_rows=selected_rows,
        eval_episodes=eval_episodes,
        eval_start_idx=eval_start_idx,
        eval_budget=int(cfg.eval.eval_budget),
        action_key=action_key,
    )

    world_image_shape = (
        int(cfg.world.get("height", cfg.eval.img_size)),
        int(cfg.world.get("width", cfg.eval.img_size)),
    )
    world = swm.World(**cfg.world, image_shape=world_image_shape)
    policy = DatasetActionReplayPolicy(oracle_actions)
    world.set_policy(policy)

    out_dir = _default_out_dir(cfg)
    out_dir.mkdir(parents=True, exist_ok=True)

    print(f"[debug-puzzle] mode=eval-stack-oracle", flush=True)
    print(f"[debug-puzzle] dataset={cfg.eval.dataset_name}", flush=True)
    print(f"[debug-puzzle] env={cfg.world.env_name}", flush=True)
    print(f"[debug-puzzle] selected_rows={selected_rows.tolist()}", flush=True)
    print(f"[debug-puzzle] episodes={eval_episodes.tolist()}", flush=True)
    print(f"[debug-puzzle] start_steps={eval_start_idx.tolist()}", flush=True)
    print(f"[debug-puzzle] oracle_actions_shape={list(oracle_actions.shape)}", flush=True)

    policy.reset()
    metrics = evaluate_from_dataset_with_progress(
        world=world,
        dataset=dataset,
        episodes_idx=eval_episodes.tolist(),
        start_steps=eval_start_idx.tolist(),
        goal_offset_steps=int(cfg.eval.goal_offset_steps),
        eval_budget=int(cfg.eval.eval_budget),
        callables=OmegaConf.to_container(cfg.eval.get("callables"), resolve=True),
        save_video=bool(cfg.eval.get("save_video", True)),
        video_path=out_dir,
    )

    summary = {
        "mode": "eval-stack-oracle",
        "dataset_name": str(cfg.eval.dataset_name),
        "env_name": str(cfg.world.env_name),
        "num_eval": int(len(selected_rows)),
        "goal_offset_steps": int(cfg.eval.goal_offset_steps),
        "eval_budget": int(cfg.eval.eval_budget),
        "selected_rows": selected_rows.tolist(),
        "episodes": eval_episodes.tolist(),
        "start_steps": eval_start_idx.tolist(),
        "selection": selection_info,
        "oracle_policy": {
            "action_key": action_key,
            "actions_shape": list(oracle_actions.shape),
            "steps_consumed": int(policy.step_idx),
            "first_action_rows": action_rows[:, : min(5, action_rows.shape[1])].tolist(),
            "last_action_rows": action_rows[:, max(0, action_rows.shape[1] - 5) :].tolist(),
        },
        "button_summary": _button_summary(dataset, selected_rows, cfg),
        "metrics": _jsonify(metrics),
        "video_dir": str(out_dir),
    }

    summary_path = out_dir / "eval_stack_oracle_summary.json"
    summary_path.write_text(json.dumps(summary, indent=2))

    print("[debug-puzzle] metrics:", json.dumps(_jsonify(metrics), indent=2), flush=True)
    print(f"[debug-puzzle] wrote {summary_path}", flush=True)

    close_fn = getattr(world.envs, "close", None)
    if callable(close_fn):
        close_fn()


if __name__ == "__main__":
    main()