scripts/validate_cfg_preflight.py

#!/usr/bin/env python
"""CPU-only validation for the staged Task 0 CFG configuration.

The validator deliberately checks the project override and canonical sidecars
without constructing a model or touching CUDA.  It is intended to fail before
Ray/FSDP is launched when a dangerous override, stale advantage tag, or path
outside the project is present.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import os
from pathlib import Path
from typing import Any

import numpy as np
import pyarrow.parquet as pq
from omegaconf import DictConfig, OmegaConf


PROJECT_ROOT = Path("/data/myx/RL_post_train").resolve()
DATA_ROOT = PROJECT_ROOT / "datasets/recap_libero10_task0"
ADVANTAGE_TAG = "recap_v1_step4000_full"
ADVANTAGE_MANIFEST = (
    PROJECT_ROOT
    / "logs/recap/advantage/recap_v1_step4000_full_sharded/manifest.json"
)
EXPECTED_SIDECARS = {
    "libero10_task0_sft": {
        "rows": 8005,
        "positive": 8005,
        "sha256": "33fa2a93ca9221cf1094cc3548e233f61663ca7205e5ca97cb20a065ab5969e8",
    },
    "libero10_task0_train": {
        "rows": 1561874,
        "positive": 468465,
        "sha256": "c25bab9e771d5f64091c0a43c57db7dcad257a96679f1825f2de2de360e8e8f9",
    },
}


def _as_dict(value: Any) -> dict[str, Any]:
    if isinstance(value, DictConfig):
        return dict(value)
    if isinstance(value, dict):
        return value
    return {}


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


def _project_path(raw: Any, label: str, errors: list[str]) -> Path | None:
    if raw is None:
        errors.append(f"missing path: {label}")
        return None
    path = Path(str(raw)).expanduser()
    if not path.is_absolute():
        path = (PROJECT_ROOT / path).resolve()
    else:
        path = path.resolve()
    try:
        path.relative_to(PROJECT_ROOT)
    except ValueError:
        errors.append(f"path outside /data/myx/RL_post_train: {label}={path}")
        return None
    return path


def _check_sidecar(split: str, errors: list[str]) -> dict[str, Any]:
    expected = EXPECTED_SIDECARS[split]
    sidecar = DATA_ROOT / split / "meta" / f"advantages_{ADVANTAGE_TAG}.parquet"
    if not sidecar.is_file():
        errors.append(f"missing canonical sidecar: {sidecar}")
        return {"path": str(sidecar), "exists": False}

    actual_hash = _sha256(sidecar)
    table = pq.read_table(
        sidecar, columns=["episode_index", "frame_index", "advantage"]
    )
    episode = table.column("episode_index").to_numpy()
    frame = table.column("frame_index").to_numpy()
    keys = np.stack([episode, frame], axis=1)
    positive = int(np.asarray(table.column("advantage").to_numpy(), dtype=bool).sum())
    report = {
        "path": str(sidecar),
        "rows": table.num_rows,
        "expected_rows": expected["rows"],
        "unique_keys": int(np.unique(keys, axis=0).shape[0]),
        "positive": positive,
        "expected_positive": expected["positive"],
        "sha256": actual_hash,
        "expected_sha256": expected["sha256"],
    }
    if table.num_rows != expected["rows"]:
        errors.append(f"{split}: row count mismatch")
    if report["unique_keys"] != expected["rows"]:
        errors.append(f"{split}: duplicate advantage keys")
    if positive != expected["positive"]:
        errors.append(f"{split}: positive count mismatch")
    if actual_hash != expected["sha256"]:
        errors.append(f"{split}: canonical sidecar sha256 mismatch")
    return report


def _check_manifest(errors: list[str]) -> dict[str, Any]:
    if not ADVANTAGE_MANIFEST.is_file():
        errors.append(f"missing advantage manifest: {ADVANTAGE_MANIFEST}")
        return {"path": str(ADVANTAGE_MANIFEST), "exists": False}
    manifest = json.loads(ADVANTAGE_MANIFEST.read_text(encoding="utf-8"))
    if manifest.get("status") != "complete":
        errors.append("advantage manifest status is not complete")
    if manifest.get("tag") != ADVANTAGE_TAG:
        errors.append("advantage manifest tag mismatch")
    merged = manifest.get("merge", {})
    if merged.get("total_rows") != sum(
        item["rows"] for item in EXPECTED_SIDECARS.values()
    ):
        errors.append("advantage manifest total_rows mismatch")
    if merged.get("unified_threshold") != -0.012778498318443243:
        errors.append("advantage manifest unified_threshold mismatch")
    return {
        "path": str(ADVANTAGE_MANIFEST),
        "status": manifest.get("status"),
        "tag": manifest.get("tag"),
        "total_rows": merged.get("total_rows"),
        "unified_threshold": merged.get("unified_threshold"),
    }


def validate(
    config_path: Path,
    mode: str,
    require_two_gpus: bool,
    effective_max_steps: int | None = None,
    effective_save_interval: int | None = None,
    effective_micro_batch_size: int | None = None,
    effective_global_batch_size: int | None = None,
    effective_num_workers: int | None = None,
    c4_kind: str = "matrix",
) -> dict[str, Any]:
    errors: list[str] = []
    config_path = config_path.resolve()
    _project_path(config_path, "config", errors)
    if not config_path.is_file():
        errors.append(f"missing config: {config_path}")
        return {"ok": False, "mode": mode, "errors": errors}

    cfg = OmegaConf.to_container(OmegaConf.load(config_path), resolve=False)
    actor = _as_dict(cfg.get("actor"))
    model = _as_dict(actor.get("model"))
    openpi = _as_dict(model.get("openpi"))
    fsdp = _as_dict(actor.get("fsdp_config"))
    runner = _as_dict(cfg.get("runner"))
    data = _as_dict(cfg.get("data"))
    cluster = _as_dict(cfg.get("cluster"))
    placement = _as_dict(cluster.get("component_placement"))

    if str(model.get("model_type")) != "cfg_model":
        errors.append("actor.model.model_type must be cfg_model")
    model_path = _project_path(model.get("model_path"), "model_path", errors)
    if model_path is not None and not model_path.exists():
        errors.append(f"model_path does not exist: {model_path}")
    if str(fsdp.get("strategy")) != "fsdp":
        errors.append("actor.fsdp_config.strategy must be fsdp")
    if str(fsdp.get("sharding_strategy")) != "full_shard":
        errors.append("actor.fsdp_config.sharding_strategy must be full_shard")
    if bool(fsdp.get("use_orig_params", True)):
        errors.append("actor.fsdp_config.use_orig_params must be false")
    if not bool(fsdp.get("gradient_checkpointing", False)):
        errors.append("actor.fsdp_config.gradient_checkpointing must be true")
    if bool(openpi.get("train_expert_only", True)):
        errors.append("CFG must use full parameters: train_expert_only must be false")
    if float(openpi.get("cfgrl_guidance_scale", 0.0)) != 1.0:
        errors.append("primary CFG guidance scale must be 1.0")
    if float(openpi.get("unconditional_prob", -1.0)) != 0.1:
        errors.append("primary CFG unconditional_prob must be 0.1")
    if str(openpi.get("guidance_type")) != "positive":
        errors.append("primary CFG guidance_type must be positive")
    if not bool(openpi.get("positive_only_conditional", False)):
        errors.append("primary CFG positive_only_conditional must be true")

    if int(runner.get("max_epochs", 0)) > 0:
        errors.append("runner.max_epochs must be -1 or non-positive")
    if str(placement.get("actor")) != "0-1":
        errors.append("cluster.component_placement.actor must be logical 0-1")
    configured_micro_batch_size = int(actor.get("micro_batch_size", 0))
    configured_global_batch_size = int(actor.get("global_batch_size", 0))
    configured_num_workers = int(data.get("num_workers", -1))
    micro_batch_size = (
        configured_micro_batch_size
        if effective_micro_batch_size is None
        else int(effective_micro_batch_size)
    )
    global_batch_size = (
        configured_global_batch_size
        if effective_global_batch_size is None
        else int(effective_global_batch_size)
    )
    num_workers = (
        configured_num_workers
        if effective_num_workers is None
        else int(effective_num_workers)
    )
    if global_batch_size <= 0 or micro_batch_size <= 0:
        errors.append("micro/global batch sizes must be positive")
    elif global_batch_size % (micro_batch_size * 2) != 0:
        errors.append("global_batch_size must divide micro_batch_size * world_size(2)")
    if num_workers < 0:
        errors.append("data.num_workers must be non-negative")
    if str(data.get("advantage_tag")) != ADVANTAGE_TAG:
        errors.append("data.advantage_tag mismatch")
    if data.get("balance_dataset_weights") is not True:
        errors.append("data.balance_dataset_weights must remain true")
    if bool(_as_dict(cfg.get("video")).get("enabled", False)):
        errors.append("video must remain disabled for training preflight")
    if bool(_as_dict(cfg.get("debug")).get("record_cuda_peak", False)) is not True:
        errors.append("debug.record_cuda_peak must be true for C2/C3 evidence")

    train_paths = data.get("train_data_paths", [])
    if not isinstance(train_paths, (list, tuple)) or len(train_paths) != 2:
        errors.append("exactly two train_data_paths (SFT and rollout) are required")
    path_reports = []
    for entry in train_paths if isinstance(train_paths, (list, tuple)) else []:
        entry_dict = _as_dict(entry)
        path = _project_path(entry_dict.get("dataset_path"), "dataset_path", errors)
        if path is not None:
            if not path.exists():
                errors.append(f"dataset_path does not exist: {path}")
            if "eval" in path.name.lower():
                errors.append(f"held-out eval path used for training: {path}")
        path_reports.append(
            {
                "path": str(path) if path is not None else None,
                "type": entry_dict.get("type"),
                "weight": entry_dict.get("weight"),
            }
        )
    types = [item.get("type") for item in path_reports]
    if types != ["sft", "rollout"]:
        errors.append(f"train_data_paths types must be [sft, rollout], got {types}")

    configured_max_steps = int(runner.get("max_steps", -1))
    configured_save_interval = int(runner.get("save_interval", 0))
    max_steps = (
        configured_max_steps
        if effective_max_steps is None
        else int(effective_max_steps)
    )
    save_interval = (
        configured_save_interval
        if effective_save_interval is None
        else int(effective_save_interval)
    )

    if mode == "c2":
        if max_steps != 1:
            errors.append("C2 runner.max_steps must be 1")
        if save_interval > 0:
            errors.append("C2 runner.save_interval must be <= 0")
        if int(data.get("num_workers", -1)) != 0:
            errors.append("C2 data.num_workers must be 0")
    if mode == "c3":
        if max_steps != 20:
            errors.append("C3 runner.max_steps must be 20")
        if save_interval != 20:
            errors.append("C3 runner.save_interval must be 20")
    if mode == "c3_resume":
        if max_steps != 21:
            errors.append("C3 resume runner.max_steps must be 21")
        if save_interval > 0:
            errors.append("C3 resume runner.save_interval must be <= 0")
    if mode == "c4":
        if max_steps < 1:
            errors.append("C4 runner.max_steps must be positive")
        if save_interval > 0:
            errors.append("C4 runner.save_interval must be <= 0")
        if c4_kind == "matrix":
            if max_steps < 10:
                errors.append("C4 matrix requires at least 10 total steps (2 warmup + 8 timed)")
            if global_batch_size != micro_batch_size * 2:
                errors.append("C4 matrix requires accumulation=1 (global = micro * world_size)")
        elif c4_kind == "accumulation":
            if global_batch_size != 512:
                errors.append("C4 accumulation benchmark requires global_batch_size=512")
            if max_steps != 1:
                errors.append("C4 accumulation benchmark requires exactly one optimizer step")
        else:
            errors.append(f"unknown C4 benchmark kind: {c4_kind}")
    if require_two_gpus:
        visible = os.environ.get("CUDA_VISIBLE_DEVICES", "")
        devices = [item for item in visible.split(",") if item.strip()]
        if len(devices) != 2:
            errors.append(
                "CUDA_VISIBLE_DEVICES must contain exactly two selected physical GPUs"
            )

    report = {
        "config": str(config_path),
        "mode": mode,
        "ok": not errors,
        "errors": errors,
        "resolved_checks": {
            "model_path": str(model_path) if model_path is not None else None,
            "placement": placement.get("actor"),
            "sharding_strategy": fsdp.get("sharding_strategy"),
            "gradient_checkpointing": fsdp.get("gradient_checkpointing"),
            "micro_batch_size": micro_batch_size,
            "global_batch_size": global_batch_size,
            "num_workers": num_workers,
            "configured_max_steps": configured_max_steps,
            "effective_max_steps": max_steps,
            "max_epochs": runner.get("max_epochs"),
            "configured_save_interval": configured_save_interval,
            "effective_save_interval": save_interval,
            "advantage_tag": data.get("advantage_tag"),
        },
        "train_data_paths": path_reports,
        "advantage_manifest": _check_manifest(errors),
        "sidecars": {
            split: _check_sidecar(split, errors) for split in EXPECTED_SIDECARS
        },
    }
    report["ok"] = not errors
    return report


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--config",
        type=Path,
        default=PROJECT_ROOT / "configs/recap/task0_cfg_recap_v1.yaml",
    )
    parser.add_argument(
        "--mode", choices=("c1", "c2", "c3", "c3_resume", "c4", "formal"), default="c1"
    )
    parser.add_argument("--require-two-gpus", action="store_true")
    parser.add_argument(
        "--effective-max-steps",
        type=int,
        help="Expected runner.max_steps after launcher-only Hydra overrides.",
    )
    parser.add_argument(
        "--effective-save-interval",
        type=int,
        help="Expected runner.save_interval after launcher-only Hydra overrides.",
    )
    parser.add_argument("--effective-micro-batch-size", type=int)
    parser.add_argument("--effective-global-batch-size", type=int)
    parser.add_argument("--effective-num-workers", type=int)
    parser.add_argument("--c4-kind", choices=("matrix", "accumulation"), default="matrix")
    args = parser.parse_args()
    report = validate(
        args.config,
        args.mode,
        args.require_two_gpus,
        effective_max_steps=args.effective_max_steps,
        effective_save_interval=args.effective_save_interval,
        effective_micro_batch_size=args.effective_micro_batch_size,
        effective_global_batch_size=args.effective_global_batch_size,
        effective_num_workers=args.effective_num_workers,
        c4_kind=args.c4_kind,
    )
    print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
    return 0 if report["ok"] else 1


if __name__ == "__main__":
    raise SystemExit(main())