#!/usr/bin/env python """Strict, CPU-only validation for an RLinf CFG checkpoint. The RLinf loader currently uses ``strict=False`` for ``full_weights.pt``. A successful call to that loader therefore does not prove that a CFG checkpoint contains the complete policy. This validator checks the checkpoint layout, the DCP training-state marker, exact model key/shape coverage, finite weights, and the copied LIBERO norm statistics before an inference smoke is attempted. It never constructs CUDA tensors. """ from __future__ import annotations import argparse import hashlib import json from dataclasses import replace from pathlib import Path from typing import Any import torch from safetensors import safe_open PROJECT_ROOT = Path("/data/myx/RL_post_train").resolve() BASE_MODEL = PROJECT_ROOT / "checkpoints/base/RLinf-Pi05-LIBERO-SFT" BASE_WEIGHTS = BASE_MODEL / "model.safetensors" BASE_NORM_STATS = BASE_MODEL / "physical-intelligence/libero/norm_stats.json" EXPECTED_BASE_WEIGHT_SHA256 = ( "4616e4c1966a5fb063b442ea5d69857f45e873222d839b794634d87d252ab9e7" ) def _sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(16 * 1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def _inside(path: Path, root: Path = PROJECT_ROOT) -> bool: try: path.resolve().relative_to(root.resolve()) except ValueError: return False return True def _resolve_project_path(raw: Path, label: str, errors: list[str]) -> Path: path = raw.expanduser() if not path.is_absolute(): path = PROJECT_ROOT / path path = path.resolve() if not _inside(path): errors.append(f"{label} is outside project root: {path}") return path def _find_layout(checkpoint: Path, errors: list[str]) -> dict[str, Path | None]: """Resolve actor root, full weights and DCP directory from common inputs.""" if checkpoint.is_file(): if checkpoint.name != "full_weights.pt": errors.append(f"checkpoint file must be full_weights.pt: {checkpoint}") weights = checkpoint model_state = checkpoint.parent actor_root = model_state.parent if model_state.name == "model_state_dict" else None else: candidates = [ checkpoint / "model_state_dict" / "full_weights.pt", checkpoint / "actor" / "model_state_dict" / "full_weights.pt", ] weights = next((candidate for candidate in candidates if candidate.is_file()), None) if weights is None: errors.append(f"missing full_weights.pt below checkpoint: {checkpoint}") actor_root = None elif weights.parent.parent.name == "actor": actor_root = weights.parent.parent else: actor_root = weights.parent.parent dcp = actor_root / "dcp_checkpoint" if actor_root is not None else None return {"actor_root": actor_root, "weights": weights, "dcp": dcp} def _expected_model_state() -> dict[str, Any]: """Build CFG metadata on ``meta`` and normalize tied state-dict aliases.""" from rlinf.models.embodiment.openpi.dataconfig import get_openpi_config from rlinf.models.embodiment.openpi_cfg.openpi_cfg_action_model import ( OpenPi0Config, OpenPi0ForCFGActionPrediction, ) base = get_openpi_config("pi05_libero").model config = replace( OpenPi0Config(**base.__dict__), train_expert_only=False, cfgrl_guidance_scale=1.0, unconditional_prob=0.1, guidance_type="positive", positive_only_conditional=True, ) with torch.device("meta"): model = OpenPi0ForCFGActionPrediction(config) try: parameters = dict(model.named_parameters()) parameter_by_id = {id(value): key for key, value in parameters.items()} state_shapes: dict[str, tuple[int, ...]] = {} alias_to_canonical: dict[str, str] = {} for key, value in model.state_dict().items(): try: canonical = parameter_by_id.get(id(model.get_parameter(key)), key) except (AttributeError, KeyError): canonical = key alias_to_canonical[key] = canonical state_shapes.setdefault(canonical, tuple(value.shape)) return { "shapes": state_shapes, "alias_to_canonical": alias_to_canonical, "parameter_keys": set(parameters), "parameter_numel": sum(value.numel() for value in parameters.values()), } finally: del model def _base_shapes(errors: list[str]) -> dict[str, tuple[int, ...]]: if not BASE_WEIGHTS.is_file(): errors.append(f"missing frozen base weights: {BASE_WEIGHTS}") return {} with safe_open(str(BASE_WEIGHTS), framework="pt", device="cpu") as handle: return {key: tuple(handle.get_slice(key).get_shape()) for key in handle.keys()} def _check_finite(state: dict[str, Any], errors: list[str]) -> dict[str, Any]: checked = 0 nonfinite: list[str] = [] chunk_size = 16 * 1024 * 1024 for key, value in state.items(): if not isinstance(value, torch.Tensor): errors.append(f"state entry is not a tensor: {key}") continue checked += 1 if value.is_floating_point() or value.is_complex(): flat = value.detach().reshape(-1) for start in range(0, flat.numel(), chunk_size): if not bool(torch.isfinite(flat[start : start + chunk_size]).all()): nonfinite.append(key) break if nonfinite: errors.append(f"non-finite tensors: {nonfinite[:8]}") return {"tensor_entries_checked": checked, "nonfinite_keys": nonfinite} def validate( checkpoint_arg: Path, *, metadata_only: bool, skip_base_hash: bool, ) -> dict[str, Any]: errors: list[str] = [] checkpoint = _resolve_project_path(checkpoint_arg, "checkpoint", errors) if not checkpoint.exists(): errors.append(f"checkpoint does not exist: {checkpoint}") layout = _find_layout(checkpoint, errors) if checkpoint.exists() else {} actor_root = layout.get("actor_root") weights = layout.get("weights") dcp = layout.get("dcp") for label, path in (("actor_root", actor_root), ("full_weights", weights), ("dcp", dcp)): if path is not None and not _inside(path): errors.append(f"{label} is outside project root: {path}") base_hash = None if BASE_WEIGHTS.is_file() and not skip_base_hash: base_hash = _sha256(BASE_WEIGHTS) if base_hash != EXPECTED_BASE_WEIGHT_SHA256: errors.append( "frozen base model SHA256 mismatch: " f"{base_hash} != {EXPECTED_BASE_WEIGHT_SHA256}" ) dcp_files: list[Path] = [] if dcp is not None: metadata = dcp / ".metadata" dcp_files = sorted(dcp.glob("__*.distcp")) if not metadata.is_file() or metadata.stat().st_size == 0: errors.append(f"missing/empty DCP metadata: {metadata}") if not dcp_files: errors.append(f"missing DCP shard files below: {dcp}") expected = _expected_model_state() if BASE_WEIGHTS.is_file() else {} base_shapes = _base_shapes(errors) expected_shapes = expected.get("shapes", {}) alias_to_canonical = expected.get("alias_to_canonical", {}) parameter_keys = expected.get("parameter_keys", set()) # The base safetensors omits one tied input-embedding alias; normalize both # names to the same parameter before checking coverage and shapes. if expected and base_shapes: for key, shape in base_shapes.items(): canonical = alias_to_canonical.get(key) if canonical is None or canonical not in expected_shapes: errors.append(f"unexpected frozen base key: {key}") elif expected_shapes[canonical] != shape: errors.append( f"base/model shape mismatch for {key}: " f"{shape} != {expected_shapes[canonical]}" ) state: dict[str, Any] | None = None weights_hash = None finite_report: dict[str, Any] = {"skipped": True} key_report: dict[str, Any] = {} if isinstance(weights, Path) and weights.is_file(): weights_hash = _sha256(weights) try: state = torch.load(weights, map_location="meta", weights_only=True) if not isinstance(state, dict): errors.append(f"full_weights.pt is not a state dict: {type(state)!r}") state = None except Exception as exc: # pragma: no cover - exercised by corrupt files errors.append(f"cannot load full_weights.pt metadata: {type(exc).__name__}: {exc}") if state is not None and expected_shapes: actual = set(state) normalized: dict[str, Any] = {} duplicate_aliases: list[str] = [] unexpected = [] for key, value in state.items(): canonical = alias_to_canonical.get(key) if canonical is None: unexpected.append(key) continue if canonical in normalized: duplicate_aliases.append(key) continue normalized[canonical] = value expected_keys = set(expected_shapes) missing = sorted(expected_keys - set(normalized)) shape_mismatch = sorted( key for key in expected_keys & set(normalized) if not isinstance(normalized[key], torch.Tensor) or tuple(normalized[key].shape) != expected_shapes[key] ) expected_numel = int(expected.get("parameter_numel", 0)) actual_numel = sum( int(normalized[key].numel()) for key in parameter_keys & set(normalized) if isinstance(normalized[key], torch.Tensor) ) key_report = { "expected_keys": len(expected_keys), "actual_keys": len(actual), "normalized_keys": len(normalized), "missing_keys": missing, "unexpected_keys": unexpected, "duplicate_aliases": sorted(duplicate_aliases), "shape_mismatch_keys": shape_mismatch, "coverage": len(expected_keys & set(normalized)) / len(expected_keys), "expected_parameter_numel": expected_numel, "actual_parameter_numel": actual_numel, } if ( missing or unexpected or shape_mismatch or actual_numel != expected_numel ): errors.append("CFG full_weights key/shape coverage is not exact") if not metadata_only and state is not None: # Reload on CPU only for finite-value checking. The first metadata # load uses meta tensors and does not allocate the model weights. cpu_state = torch.load(weights, map_location="cpu", weights_only=True) if isinstance(cpu_state, dict): finite_report = _check_finite(cpu_state, errors) else: errors.append("CPU full_weights reload is not a state dict") norm_candidates: list[Path] = [] if actor_root is not None: norm_candidates.append(actor_root / "physical-intelligence/libero/norm_stats.json") norm_candidates.append(actor_root.parent / "physical-intelligence/libero/norm_stats.json") norm_path = next((path for path in norm_candidates if path.is_file()), None) norm_hash = None if norm_path is None: errors.append("checkpoint is missing copied physical-intelligence/libero/norm_stats.json") else: try: json.loads(norm_path.read_text(encoding="utf-8")) except Exception as exc: errors.append(f"invalid checkpoint norm_stats.json: {type(exc).__name__}: {exc}") norm_hash = _sha256(norm_path) if BASE_NORM_STATS.is_file() and norm_hash != _sha256(BASE_NORM_STATS): errors.append("checkpoint norm_stats.json SHA256 differs from frozen base") report = { "checkpoint": str(checkpoint), "actor_root": str(actor_root) if actor_root is not None else None, "full_weights": str(weights) if isinstance(weights, Path) else None, "full_weights_sha256": weights_hash, "dcp": { "path": str(dcp) if dcp is not None else None, "metadata_present": bool(dcp and (dcp / ".metadata").is_file()), "shard_count": len(dcp_files), }, "base_model": { "path": str(BASE_WEIGHTS), "sha256": base_hash, "expected_sha256": EXPECTED_BASE_WEIGHT_SHA256, "key_count": len(base_shapes), }, "norm_stats": { "path": str(norm_path) if norm_path is not None else None, "sha256": norm_hash, "base_sha256": _sha256(BASE_NORM_STATS) if BASE_NORM_STATS.is_file() else None, }, "key_coverage": key_report, "finite": finite_report, "metadata_only": metadata_only, "ok": not errors, "errors": errors, } return report def main() -> int: parser = argparse.ArgumentParser() parser.add_argument("--checkpoint", type=Path, required=True) parser.add_argument( "--metadata-only", action="store_true", help="Skip the CPU reload used for finite-value checking.", ) parser.add_argument( "--skip-base-hash", action="store_true", help="Do not hash the frozen 7.5GB base safetensors file.", ) args = parser.parse_args() report = validate( args.checkpoint, metadata_only=args.metadata_only, skip_base_hash=args.skip_base_hash, ) 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())