scripts/task0_baseline_common.py

#!/usr/bin/env python
"""Shared protocol, result and statistics helpers for Task 0 baseline runs."""

from __future__ import annotations

import hashlib
import json
import math
import os
import re
import tempfile
from pathlib import Path
from typing import Any, Iterable

from omegaconf import DictConfig, OmegaConf


PROJECT_ROOT = Path("/data/myx/RL_post_train").resolve()
RESULT_SCHEMA_VERSION = "task0_baseline_episode_v1"
_RANGE_RE = re.compile(r"^(?P<start>\d+)(?:-(?P<end>\d+))?$")


def require_project_path(path: str | Path, *, label: str) -> Path:
    """Resolve a path and reject writes outside the project data boundary."""
    resolved = Path(path).expanduser().resolve()
    try:
        resolved.relative_to(Path("/data/myx").resolve())
    except ValueError as exc:
        raise ValueError(f"{label} must remain under /data/myx/: {resolved}") from exc
    return resolved


def load_config(path: str | Path) -> DictConfig:
    path = require_project_path(path, label="config")
    if not path.is_file():
        raise FileNotFoundError(path)
    return OmegaConf.load(path)


def resolved_config_container(cfg: DictConfig) -> dict[str, Any]:
    value = OmegaConf.to_container(cfg, resolve=True)
    if not isinstance(value, dict):
        raise TypeError("baseline config must resolve to a mapping")
    return value


def protocol_hash(cfg: DictConfig) -> str:
    payload = json.dumps(
        resolved_config_container(cfg),
        ensure_ascii=False,
        sort_keys=True,
        separators=(",", ":"),
    ).encode("utf-8")
    return hashlib.sha256(payload).hexdigest()


def write_resolved_config(path: str | Path, cfg: DictConfig) -> None:
    path = require_project_path(path, label="resolved config")
    path.parent.mkdir(parents=True, exist_ok=True)
    OmegaConf.save(cfg, path, resolve=True)


def parse_int_spec(spec: str | Iterable[int], *, label: str) -> list[int]:
    """Parse `0,2-4` style integer specifications deterministically."""
    if not isinstance(spec, str):
        values = [int(item) for item in spec]
    else:
        values: list[int] = []
        for token in (part.strip() for part in spec.split(",")):
            if not token:
                continue
            match = _RANGE_RE.fullmatch(token)
            if not match:
                raise ValueError(f"invalid {label} token: {token!r}")
            start = int(match.group("start"))
            end = int(match.group("end") or start)
            if end < start:
                raise ValueError(f"descending {label} range: {token!r}")
            values.extend(range(start, end + 1))
    if not values:
        raise ValueError(f"{label} cannot be empty")
    unique = sorted(set(values))
    if len(unique) != len(values):
        raise ValueError(f"{label} contains duplicates")
    return unique


def expected_keys(seeds: Iterable[int], trial_ids: Iterable[int]) -> list[tuple[int, int]]:
    return [(int(seed), int(trial)) for seed in seeds for trial in trial_ids]


def episode_seed(policy_seed: int, trial_id: int, multiplier: int = 1000) -> int:
    if policy_seed < 0 or trial_id < 0 or multiplier <= 0:
        raise ValueError("seed components must be non-negative and multiplier positive")
    return int(policy_seed) * int(multiplier) + int(trial_id)


def sha256_file(path: str | Path) -> str:
    path = Path(path)
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for block in iter(lambda: handle.read(8 * 1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def atomic_json_dump(path: str | Path, payload: dict[str, Any]) -> None:
    path = require_project_path(path, label="result")
    path.parent.mkdir(parents=True, exist_ok=True)
    fd, temporary = tempfile.mkstemp(prefix=f".{path.name}.", suffix=".tmp", dir=path.parent)
    temporary_path = Path(temporary)
    try:
        with os.fdopen(fd, "w", encoding="utf-8") as handle:
            json.dump(payload, handle, ensure_ascii=False, indent=2, sort_keys=True)
            handle.write("\n")
            handle.flush()
            os.fsync(handle.fileno())
        os.replace(temporary_path, path)
    finally:
        temporary_path.unlink(missing_ok=True)


def wilson_interval(successes: int, trials: int, z: float = 1.959963984540054) -> tuple[float, float]:
    if trials < 0 or successes < 0 or successes > trials:
        raise ValueError("successes/trials must satisfy 0 <= successes <= trials")
    if trials == 0:
        return (math.nan, math.nan)
    p = successes / trials
    z2 = z * z
    denominator = 1.0 + z2 / trials
    center = (p + z2 / (2.0 * trials)) / denominator
    half = z * math.sqrt(p * (1.0 - p) / trials + z2 / (4.0 * trials * trials)) / denominator
    return (max(0.0, center - half), min(1.0, center + half))


REQUIRED_FIELDS = {
    "schema_version",
    "protocol_version",
    "protocol_sha256",
    "run_id",
    "policy_role",
    "benchmark",
    "task_id",
    "task_name",
    "trial_id",
    "init_state_sha256",
    "policy_seed",
    "episode_seed",
    "checkpoint_repo",
    "checkpoint_revision",
    "checkpoint_weight_sha256",
    "checkpoint_local_path_relative",
    "rlinf_commit",
    "openpi_commit",
    "libero_commit",
    "max_episode_steps",
    "reset_settle_steps",
    "denoise_steps",
    "noise_level",
    "num_action_chunks_executed",
    "torch_compile_enabled",
    "success_once",
    "success_step",
    "env_steps",
    "raw_env_return",
    "rlinf_return",
    "status",
    "retry_count",
    "started_at",
    "finished_at",
    "elapsed_seconds",
    "gpu_logical_id",
    "gpu_physical_id_if_known",
    "error_type",
    "error_message",
    "video_path",
}


def validate_episode_record(record: dict[str, Any], *, expected_protocol_hash: str | None = None) -> None:
    missing = sorted(REQUIRED_FIELDS - record.keys())
    if missing:
        raise ValueError(f"episode record missing fields: {', '.join(missing)}")
    if record["schema_version"] != RESULT_SCHEMA_VERSION:
        raise ValueError(f"unexpected schema_version: {record['schema_version']!r}")
    if expected_protocol_hash and record["protocol_sha256"] != expected_protocol_hash:
        raise ValueError("episode protocol hash does not match config")
    if record["status"] not in {"completed", "error"}:
        raise ValueError(f"invalid episode status: {record['status']!r}")
    if not isinstance(record["trial_id"], int) or record["trial_id"] < 0:
        raise ValueError("trial_id must be a non-negative integer")
    if not isinstance(record["policy_seed"], int) or record["policy_seed"] < 0:
        raise ValueError("policy_seed must be a non-negative integer")
    if record["status"] == "completed":
        if not isinstance(record["success_once"], bool):
            raise ValueError("completed success_once must be bool")
        if not (1 <= int(record["env_steps"]) <= int(record["max_episode_steps"])):
            raise ValueError("completed env_steps outside episode horizon")
    if record["video_path"] is not None:
        raise ValueError("formal baseline records must not contain video_path")


def load_episode_records(input_dir: str | Path, *, expected_protocol_hash: str | None = None) -> list[dict[str, Any]]:
    root = require_project_path(input_dir, label="result directory")
    episode_root = root / "episodes"
    records: list[dict[str, Any]] = []
    if not episode_root.is_dir():
        return records
    for path in sorted(episode_root.glob("seed_*/trial_*.json")):
        with path.open("r", encoding="utf-8") as handle:
            record = json.load(handle)
        if not isinstance(record, dict):
            raise ValueError(f"episode record is not an object: {path}")
        validate_episode_record(record, expected_protocol_hash=expected_protocol_hash)
        try:
            file_seed = int(path.parent.name.removeprefix("seed_"))
            file_trial = int(path.stem.removeprefix("trial_"))
        except ValueError as exc:
            raise ValueError(f"invalid episode result filename: {path}") from exc
        record_key = (int(record["policy_seed"]), int(record["trial_id"]))
        if record_key != (file_seed, file_trial):
            raise ValueError(
                f"episode path/key mismatch: path={(file_seed, file_trial)}, record={record_key}"
            )
        records.append(record)
    return records


def validate_key_set(
    records: Iterable[dict[str, Any]],
    expected: Iterable[tuple[int, int]],
) -> dict[str, Any]:
    expected_set = {(int(seed), int(trial)) for seed, trial in expected}
    observed: list[tuple[int, int]] = []
    for record in records:
        observed.append((int(record["policy_seed"]), int(record["trial_id"])))
    observed_set = set(observed)
    duplicates = sorted({key for key in observed if observed.count(key) > 1})
    return {
        "expected_count": len(expected_set),
        "observed_count": len(observed),
        "unique_count": len(observed_set),
        "missing": [list(key) for key in sorted(expected_set - observed_set)],
        "unexpected": [list(key) for key in sorted(observed_set - expected_set)],
        "duplicates": [list(key) for key in duplicates],
    }


def summarize_records(
    records: list[dict[str, Any]],
    *,
    expected: list[tuple[int, int]],
    protocol_version: str,
    protocol_sha256: str,
) -> dict[str, Any]:
    key_report = validate_key_set(records, expected)
    completed = [record for record in records if record["status"] == "completed"]
    errors = [record for record in records if record["status"] == "error"]
    successes = [record for record in completed if record["success_once"]]
    n = len(completed)
    k = len(successes)
    ci_low, ci_high = wilson_interval(k, n)

    def values(field: str, subset: list[dict[str, Any]]) -> list[float]:
        return [float(item[field]) for item in subset if item[field] is not None]

    steps = values("env_steps", completed)
    raw_returns = values("raw_env_return", completed)
    success_steps = values("success_step", successes)

    def stats(items: list[float]) -> dict[str, float | None]:
        if not items:
            return {"mean": None, "std": None, "median": None}
        mean = sum(items) / len(items)
        variance = sum((item - mean) ** 2 for item in items) / len(items)
        return {"mean": mean, "std": math.sqrt(variance), "median": sorted(items)[len(items) // 2]}

    per_seed: dict[str, Any] = {}
    for seed in sorted({seed for seed, _ in expected}):
        seed_records = [item for item in completed if int(item["policy_seed"]) == seed]
        seed_successes = sum(bool(item["success_once"]) for item in seed_records)
        seed_low, seed_high = wilson_interval(seed_successes, len(seed_records))
        per_seed[str(seed)] = {
            "planned": sum(1 for item_seed, _ in expected if item_seed == seed),
            "completed": len(seed_records),
            "success_count": seed_successes,
            "failure_count": len(seed_records) - seed_successes,
            "error_count": sum(int(item["policy_seed"]) == seed for item in errors),
            "success_rate": seed_successes / len(seed_records) if seed_records else None,
            "wilson_95ci": [seed_low, seed_high] if seed_records else [None, None],
        }

    status = "baseline_v2_complete" if n == len(expected) and not errors and not key_report["missing"] and not key_report["duplicates"] else "incomplete"
    if len(expected) == 50 and status == "baseline_v2_complete":
        status = "baseline_v1_complete"
    return {
        "schema_version": RESULT_SCHEMA_VERSION,
        "protocol_version": protocol_version,
        "protocol_sha256": protocol_sha256,
        "planned_episode_count": len(expected),
        "observed_episode_count": len(records),
        "unique_episode_count": key_report["unique_count"],
        "completed_episode_count": n,
        "error_episode_count": len(errors),
        "success_count": k,
        "failure_count": n - k,
        "success_rate": k / n if n else None,
        "wilson_95ci": [ci_low, ci_high] if n else [None, None],
        "key_report": key_report,
        "episode_steps": stats(steps),
        "raw_env_return": stats(raw_returns),
        "success_step": stats(success_steps),
        "per_policy_seed": per_seed,
        "videos_present": False,
        "status": status,
    }