| |
| """Compare explicit StatePlay state traces with the selected dataset states.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| import torch |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| if str(ROOT) not in sys.path: |
| sys.path.insert(0, str(ROOT)) |
|
|
| from stateplay.utils.state import ( |
| STATE_COLUMNS, |
| STATE_NORM_MAX, |
| denormalize_state, |
| load_true_state, |
| ) |
|
|
|
|
| def summarize(distances: np.ndarray) -> dict[str, object]: |
| per_state = distances.mean(axis=(0, 1)) |
| distance = float(per_state.mean()) |
| return { |
| "samples": int(distances.shape[0]), |
| "latent_frames_per_sample": int(distances.shape[1]), |
| "distance": distance, |
| "score": 1.0 - distance, |
| "per_state_distance": dict(zip(STATE_COLUMNS, map(float, per_state))), |
| "per_state_score": dict(zip(STATE_COLUMNS, map(lambda x: 1.0 - float(x), per_state))), |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--selection", type=Path, required=True) |
| parser.add_argument("--predictions", type=Path, required=True) |
| parser.add_argument("--output", type=Path, required=True) |
| args = parser.parse_args() |
| samples = json.loads(args.selection.read_text(encoding="utf-8"))["samples"] |
| norm_max = STATE_NORM_MAX.numpy() |
| all_distances = [] |
| by_label = defaultdict(list) |
| max_true_disagreement = 0.0 |
|
|
| for sample in samples: |
| video_name = Path(sample["output_name"]) |
| state_path = args.predictions / f"{video_name.stem}_state.txt" |
| trace = pd.read_csv(state_path, sep=r"\s+") |
| frames = len(trace) |
| if frames != 26 or not np.array_equal(trace["frame"].to_numpy(), np.arange(frames)): |
| raise ValueError(f"Unexpected latent-frame trace in {state_path}: {frames} rows") |
| predicted = trace[[f"{name}_pred" for name in STATE_COLUMNS]].to_numpy(dtype=np.float64) |
| recorded_true = trace[[f"{name}_true" for name in STATE_COLUMNS]].to_numpy(dtype=np.float64) |
| normalized_true = load_true_state( |
| sample["actions"], num_frames=101, latent_frames=frames, |
| sampling="end", device="cpu", dtype=torch.bfloat16, |
| ) |
| target = denormalize_state(normalized_true.float()).squeeze(0).numpy() |
| disagreement = float(np.max(np.abs(recorded_true - target))) |
| max_true_disagreement = max(max_true_disagreement, disagreement) |
| if disagreement > 0.002: |
| raise ValueError(f"Saved true trace differs from source parquet: {state_path} ({disagreement})") |
| if not np.isfinite(predicted).all() or not np.isfinite(target).all(): |
| raise ValueError(f"Non-finite state value in {state_path}") |
| distance = np.abs(predicted - target) / norm_max |
| all_distances.append(distance) |
| by_label[sample["label"]].append(distance) |
|
|
| distances = np.stack(all_distances) |
| report = { |
| "selection": str(args.selection.resolve()), |
| "predictions": str(args.predictions.resolve()), |
| "normalization_max": dict(zip(STATE_COLUMNS, map(float, norm_max))), |
| "definition": "1 - mean(abs(predicted_raw - target_raw) / state_max) over samples, latent frames, and five variables", |
| "state_sampling": "end", |
| "max_saved_true_vs_parquet_difference": max_true_disagreement, |
| "all_frames": summarize(distances), |
| "excluding_pinned_initial_frame": summarize(distances[:, 1:]), |
| "by_label": {label: summarize(np.stack(values)) for label, values in sorted(by_label.items())}, |
| } |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| args.output.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8") |
| print(json.dumps(report, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
