| |
| """Validate the multi-config public data interface (local; CI later). |
| |
| Checks: |
| - hardware_re4 parquet columns/dtypes match the expected full schema |
| - sr_pareto consolidated table has required columns and non-empty coverage |
| - latent_routing gate: fail if README declares the config without three CSVs |
| - bundle.json should not be the sole SR interface (warn on absolute paths) |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| import sys |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
| |
| HARDWARE_RE4_SCHEMA: dict[str, str] = { |
| "timestamp_ms": "int64", |
| "power_usage_mw": "uint32", |
| "temperature_c": "uint32", |
| "graphics_clock_mhz": "uint32", |
| "memory_clock_mhz": "uint32", |
| "pcie_rx_kbps": "uint32", |
| "pcie_tx_kbps": "uint32", |
| "pstate": "uint32", |
| "throttle_reasons_bitmask": "uint64", |
| "fan_speed_perc": "uint32", |
| "memory_used_mb": "uint64", |
| "memory_total_mb": "uint64", |
| "encoder_util_perc": "uint32", |
| "decoder_util_perc": "uint32", |
| "cpu_tctl_c": "double", |
| "cpu_ccd1_c": "double", |
| "cpu_ccd2_c": "double", |
| "cpu_package_power_w": "double", |
| } |
|
|
| SR_REQUIRED = {"model", "condition", "complexity", "loss", "equation"} |
|
|
| LATENT_CSVS = [ |
| ROOT / "first-day-testing-real-weights/second-test/snn_latent_telemetry.csv", |
| ROOT / "first-day-testing-real-weights/third-test/snn_latent_telemetry.csv", |
| ROOT / "first-day-testing-real-weights/fourth-test/snn_latent_telemetry.csv", |
| ] |
|
|
|
|
| def _normalize_type(t: str) -> str: |
| t = str(t).lower() |
| aliases = { |
| "float": "double", |
| "float32": "float", |
| "float64": "double", |
| "boolean": "bool", |
| } |
| return aliases.get(t, t) |
|
|
|
|
| def check_hardware_re4(root: Path, errors: list[str], warnings: list[str]) -> None: |
| try: |
| import pyarrow.parquet as pq |
| except ImportError: |
| errors.append("pyarrow required to validate hardware_re4 parquet") |
| return |
|
|
| pattern = root / "origin_hardware_baselines/resident_evil_4" |
| files = sorted(pattern.glob("system_telemetry_v1_batch_*.parquet")) |
| if len(files) < 1: |
| errors.append("no system_telemetry_v1_batch_*.parquet files found") |
| return |
| if len(files) != 48: |
| warnings.append(f"expected 48 RE4 parquet batches, found {len(files)}") |
|
|
| table = pq.read_table(files[0]) |
| actual = {f.name: _normalize_type(str(f.type)) for f in table.schema} |
| expected = {k: _normalize_type(v) for k, v in HARDWARE_RE4_SCHEMA.items()} |
|
|
| missing = sorted(set(expected) - set(actual)) |
| extra = sorted(set(actual) - set(expected)) |
| if missing: |
| errors.append(f"hardware_re4 missing columns: {missing}") |
| if extra: |
| warnings.append(f"hardware_re4 extra columns vs CONTEXT schema: {extra}") |
|
|
| for name, exp_t in expected.items(): |
| if name not in actual: |
| continue |
| |
| act = actual[name] |
| if act == exp_t: |
| continue |
| if {act, exp_t} <= {"float", "double"}: |
| continue |
| if {act, exp_t} <= {"int64", "uint64"} and name == "throttle_reasons_bitmask": |
| continue |
| errors.append(f"hardware_re4 dtype mismatch {name}: got {act}, expected {exp_t}") |
|
|
| total_rows = sum(pq.read_table(f).num_rows for f in files) |
| if total_rows < 1000: |
| errors.append(f"hardware_re4 too few rows: {total_rows}") |
| else: |
| print(f" hardware_re4: {len(files)} files, {total_rows} rows, schema OK") |
|
|
|
|
| def check_sr_pareto(root: Path, errors: list[str], warnings: list[str]) -> None: |
| csv_path = root / "sr_benchmark/sr_pareto_all.csv" |
| pq_path = root / "sr_benchmark/sr_pareto_all.parquet" |
| if not csv_path.exists() and not pq_path.exists(): |
| errors.append("sr_pareto_all.csv/.parquet missing — run scripts/build_sr_pareto_all.py") |
| return |
|
|
| import csv |
|
|
| path = csv_path if csv_path.exists() else pq_path |
| if path.suffix == ".csv": |
| with path.open(newline="", encoding="utf-8") as f: |
| reader = csv.DictReader(f) |
| fields = set(reader.fieldnames or []) |
| rows = list(reader) |
| else: |
| import pyarrow.parquet as pq |
|
|
| table = pq.read_table(path) |
| fields = set(table.column_names) |
| rows = table.to_pylist() |
|
|
| missing = SR_REQUIRED - fields |
| if missing: |
| errors.append(f"sr_pareto missing columns: {sorted(missing)}") |
| return |
| if not rows: |
| errors.append("sr_pareto consolidated table is empty") |
| return |
|
|
| models = {r["model"] for r in rows} |
| conditions = {r["condition"] for r in rows} |
| if len(models) < 2: |
| warnings.append(f"sr_pareto few models: {sorted(models)}") |
| if not conditions: |
| errors.append("sr_pareto has no conditions") |
| print( |
| f" sr_pareto: {len(rows)} rows, {len(models)} models, " |
| f"{len(conditions)} conditions" |
| ) |
|
|
| bundle = root / "sr_benchmark/bundle.json" |
| if bundle.exists(): |
| text = bundle.read_text(encoding="utf-8") |
| abs_hits = re.findall(r'"/home/[^"]+"', text) |
| if abs_hits: |
| warnings.append( |
| f"bundle.json still has {len(abs_hits)} absolute path strings " |
| "(consolidated table is the Hub interface; fix paths when convenient)" |
| ) |
|
|
|
|
| def check_latent_gate(root: Path, errors: list[str], warnings: list[str]) -> None: |
| readme = (root / "README.md").read_text(encoding="utf-8") |
| has_latent_config = bool( |
| re.search(r"config_name:\s*latent_routing", readme) |
| or re.search(r'["\']latent_routing["\']', readme.split("---", 2)[1] if readme.startswith("---") else "") |
| ) |
| present = [p for p in LATENT_CSVS if p.exists()] |
| missing = [p for p in LATENT_CSVS if not p.exists()] |
|
|
| if has_latent_config and missing: |
| errors.append( |
| "latent_routing config declared in README but feature CSVs missing: " |
| + ", ".join(str(p.relative_to(root)) for p in missing) |
| ) |
| elif missing: |
| warnings.append( |
| "latent_routing gated (expected): missing " |
| + ", ".join(str(p.relative_to(root)) for p in missing) |
| ) |
| else: |
| print(" latent_routing gate: all three feature CSVs present") |
|
|
| if present and not has_latent_config and not missing: |
| warnings.append( |
| "all latent CSVs present but latent_routing config not in README yet" |
| ) |
|
|
|
|
| def check_readme_configs(root: Path, errors: list[str], warnings: list[str]) -> None: |
| readme = (root / "README.md").read_text(encoding="utf-8") |
| if not readme.startswith("---"): |
| errors.append("README.md missing YAML frontmatter") |
| return |
| parts = readme.split("---", 2) |
| if len(parts) < 3: |
| errors.append("README.md YAML frontmatter malformed") |
| return |
| yaml = parts[1] |
| if re.search(r"config_name:\s*default\b", yaml): |
| errors.append("README still has config_name: default (must force explicit configs)") |
| for name in ("hardware_re4", "sr_pareto"): |
| if f"config_name: {name}" not in yaml and f'config_name: "{name}"' not in yaml: |
| errors.append(f"README YAML missing config_name: {name}") |
| if "sr_pareto_all" not in yaml: |
| warnings.append("README YAML may not point data_files at sr_pareto_all.*") |
| |
| if readme.count("\n## Usage\n") > 1: |
| errors.append("README has duplicate ## Usage sections") |
| print(" README configs: checked") |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--root", type=Path, default=ROOT) |
| args = parser.parse_args() |
| root: Path = args.root |
|
|
| errors: list[str] = [] |
| warnings: list[str] = [] |
|
|
| print("validate_dataset") |
| check_readme_configs(root, errors, warnings) |
| check_hardware_re4(root, errors, warnings) |
| check_sr_pareto(root, errors, warnings) |
| check_latent_gate(root, errors, warnings) |
|
|
| for w in warnings: |
| print(f"WARN: {w}") |
| for e in errors: |
| print(f"ERROR: {e}") |
|
|
| if errors: |
| print(f"FAILED ({len(errors)} error(s), {len(warnings)} warning(s))") |
| return 1 |
| print(f"OK ({len(warnings)} warning(s))") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
