| |
| """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()) |
| |
| |
| 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: |
| 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: |
| |
| |
| 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()) |
|
|
