scripts/omni/analyze_qwen3_omni_errors.py

#!/usr/bin/env python3
"""Analyze public-safe held-out structured JSON prediction errors.

The script consumes a verified public package or a raw eval directory plus a
public-safe episode manifest, not raw Xperience-10M data. It summarizes where
the diagnostic pilot fails by episode, train-seen status,
coarse action family, object category, parsed prediction state, and
required-modality state. The outputs are small derived CSV/JSON/Markdown
artifacts suitable for the public package.
"""

from __future__ import annotations

import argparse
import csv
import json
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any


DEFAULT_PACKAGE = (
    Path(__file__).resolve().parents[2]
    / "results/omni_finetune/verified_public/"
    / "xperience10m_qwen3_omni_128ep_96train_16val_16test_valmon_20260605_eval"
)
ROOT = Path(__file__).resolve().parents[2]

ACTION_FAMILIES = [
    ("phone_use", ("phone", "smartphone", "watch", "screen")),
    ("paper_cardboard_craft", ("paper", "cardboard", "fold", "cut", "draw", "mark", "ruler", "scissors", "lantern", "star")),
    ("retail_stocking", ("shelf", "product", "can", "canned", "container", "box", "grocery", "stock")),
    ("small_object_sorting", ("bead", "button", "tile", "mahjong", "puzzle", "piece")),
    ("cleaning", ("clean", "wipe", "wash", "vacuum", "sweep", "trash")),
    ("locomotion", ("walk", "approach", "enter", "move through", "arrive", "leave")),
    ("food_kitchen", ("kettle", "rice", "saucepan", "kitchen", "bottle", "jar", "lid")),
]

OBJECT_CATEGORIES = [
    ("phone_device", ("phone", "smartphone", "watch", "charger", "cable", "power bank", "earbud")),
    ("paper_cardboard", ("paper", "cardboard", "lantern", "origami", "star", "ribbon")),
    ("tool_stationery", ("scissors", "knife", "ruler", "marker", "pen", "stapler", "glue", "tape")),
    ("retail_container", ("shelf", "container", "product", "box", "can", "canned", "package", "bag")),
    ("furniture_room", ("table", "chair", "desk", "counter", "sink", "door", "wall", "floor")),
    ("food_kitchen", ("kettle", "rice", "saucepan", "jar", "bottle", "food", "kitchen")),
    ("craft_small_object", ("bead", "button", "tile", "mahjong", "puzzle", "foam", "piece")),
    ("cleaning", ("vacuum", "broom", "cloth", "towel", "trash")),
]

REQUIRED_VIDEO_FILES = {
    "fisheye_cam0.mp4",
    "fisheye_cam1.mp4",
    "fisheye_cam2.mp4",
    "fisheye_cam3.mp4",
    "stereo_left.mp4",
    "stereo_right.mp4",
}

REQUIRED_HDF5_MODALITIES = {
    "calibration",
    "slam_pose",
    "slam_point_cloud",
    "depth",
    "depth_confidence",
    "hand_mocap",
    "body_mocap",
    "contacts",
    "imu",
    "caption",
}


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--package-dir", type=Path, default=DEFAULT_PACKAGE)
    parser.add_argument("--eval-dir", type=Path, help="Raw or packaged eval directory containing predictions.jsonl and metrics.json.")
    parser.add_argument("--dataset-dir", type=Path, help="Directory containing a public-safe episode_manifest.json.")
    parser.add_argument("--episode-manifest", type=Path, help="Explicit public-safe episode manifest JSON.")
    parser.add_argument("--output-dir", type=Path)
    parser.add_argument("--model-label", default="Qwen3-Omni")
    parser.add_argument("--max-examples", type=int, default=12)
    return parser.parse_args()


def load_json(path: Path) -> dict[str, Any]:
    return json.loads(path.read_text(encoding="utf-8"))


def public_path(path: Path) -> str:
    try:
        return path.resolve().relative_to(ROOT).as_posix()
    except ValueError:
        return path.name


def load_jsonl(path: Path) -> list[dict[str, Any]]:
    rows = []
    with path.open("r", encoding="utf-8") as handle:
        for line in handle:
            line = line.strip()
            if line:
                rows.append(json.loads(line))
    return rows


def norm(value: Any) -> str:
    return str(value or "").strip().lower()


def family_for(text: str, families: list[tuple[str, tuple[str, ...]]], fallback: str = "other") -> str:
    low = norm(text)
    for name, keywords in families:
        if any(keyword in low for keyword in keywords):
            return name
    return fallback


def object_categories(objects: list[Any]) -> set[str]:
    categories: set[str] = set()
    for obj in objects:
        categories.add(family_for(str(obj), OBJECT_CATEGORIES, "other_object"))
    return categories or {"no_object_label"}


def f1(precision: float, recall: float) -> float:
    if precision + recall == 0:
        return 0.0
    return 2 * precision * recall / (precision + recall)


def bool_metric(row: dict[str, Any], key: str) -> bool:
    true_json = row.get("true_json") or {}
    pred_json = row.get("pred_json") or {}
    return norm(true_json.get(key)) == norm(pred_json.get(key)) and bool(pred_json)


def object_overlap(row: dict[str, Any]) -> tuple[int, int, int]:
    true_objects = {norm(item) for item in (row.get("true_json") or {}).get("objects", []) if norm(item)}
    pred_objects = {norm(item) for item in (row.get("pred_json") or {}).get("objects", []) if norm(item)}
    return len(true_objects & pred_objects), len(pred_objects), len(true_objects)


def modality_state(episode: dict[str, Any] | None) -> tuple[str, list[str]]:
    if not episode:
        return "episode_manifest_missing", ["episode_manifest_missing"]
    missing: list[str] = []
    files = {str(item.get("name")): bool(item.get("exists")) for item in episode.get("files", [])}
    for filename in sorted(REQUIRED_VIDEO_FILES):
        if not files.get(filename):
            missing.append(filename)
    hdf5 = episode.get("hdf5_modalities") or {}
    for modality in sorted(REQUIRED_HDF5_MODALITIES):
        if not hdf5.get(modality):
            missing.append(modality)
    if missing:
        return "missing_required_modalities", missing
    if files.get("visualization.rrd") is False:
        return "rrd_missing_only_required_modalities_present", ["visualization.rrd"]
    return "required_modalities_present", []


def add_row_stats(bucket: dict[str, Any], row: dict[str, Any]) -> None:
    bucket["samples"] += 1
    valid = bool(row.get("pred_json"))
    bucket["parsed_predictions"] += int(valid)
    bucket["action_exact"] += int(bool_metric(row, "action"))
    bucket["subtask_exact"] += int(bool_metric(row, "subtask"))
    bucket["transition_exact"] += int(bool_metric(row, "transition"))
    bucket["next_action_exact"] += int(bool_metric(row, "next_action"))
    bucket["contact_exact"] += int(bool_metric(row, "contact"))
    matched, pred_count, true_count = object_overlap(row)
    bucket["object_matched"] += matched
    bucket["object_predicted"] += pred_count
    bucket["object_true"] += true_count


def empty_bucket() -> dict[str, Any]:
    return {
        "samples": 0,
        "parsed_predictions": 0,
        "action_exact": 0,
        "subtask_exact": 0,
        "transition_exact": 0,
        "next_action_exact": 0,
        "contact_exact": 0,
        "object_matched": 0,
        "object_predicted": 0,
        "object_true": 0,
    }


def finalize_bucket(name: str, bucket: dict[str, Any]) -> dict[str, Any]:
    samples = max(int(bucket["samples"]), 1)
    precision = bucket["object_matched"] / bucket["object_predicted"] if bucket["object_predicted"] else 0.0
    recall = bucket["object_matched"] / bucket["object_true"] if bucket["object_true"] else 0.0
    return {
        "group": name,
        "samples": bucket["samples"],
        "parsed_prediction_rate": bucket["parsed_predictions"] / samples,
        "action_exact_rate": bucket["action_exact"] / samples,
        "subtask_exact_rate": bucket["subtask_exact"] / samples,
        "transition_exact_rate": bucket["transition_exact"] / samples,
        "next_action_exact_rate": bucket["next_action_exact"] / samples,
        "contact_exact_rate": bucket["contact_exact"] / samples,
        "object_precision": precision,
        "object_recall": recall,
        "object_f1": f1(precision, recall),
    }


def write_csv(path: Path, rows: list[dict[str, Any]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        path.write_text("", encoding="utf-8")
        return
    with path.open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()), lineterminator="\n")
        writer.writeheader()
        writer.writerows(rows)


def top_rows(groups: dict[str, dict[str, Any]], *, min_samples: int = 1, reverse: bool = False) -> list[dict[str, Any]]:
    rows = [finalize_bucket(name, bucket) for name, bucket in groups.items() if bucket["samples"] >= min_samples]
    return sorted(rows, key=lambda row: (row["parsed_prediction_rate"], row["action_exact_rate"], row["samples"]), reverse=reverse)


def markdown_table(rows: list[dict[str, Any]], columns: list[str], limit: int = 8) -> list[str]:
    selected = rows[:limit]
    if not selected:
        return ["No rows."]
    lines = ["| " + " | ".join(columns) + " |", "| " + " | ".join("---" for _ in columns) + " |"]
    for row in selected:
        values = []
        for col in columns:
            value = row.get(col)
            if isinstance(value, float):
                values.append(f"{value:.4f}")
            else:
                values.append(str(value))
        lines.append("| " + " | ".join(values) + " |")
    return lines


def main() -> int:
    args = parse_args()
    package_dir = args.package_dir.expanduser().resolve()
    raw_eval_mode = args.eval_dir is not None
    eval_dir = args.eval_dir.expanduser().resolve() if args.eval_dir else package_dir / "eval"
    dataset_dir = args.dataset_dir.expanduser().resolve() if args.dataset_dir else package_dir / "dataset"
    episode_manifest_path = (
        args.episode_manifest.expanduser().resolve()
        if args.episode_manifest
        else dataset_dir / "episode_manifest.json"
    )
    output_dir = args.output_dir or (eval_dir / "analysis" if raw_eval_mode else package_dir / "analysis")
    output_dir = output_dir.expanduser().resolve()

    predictions = load_jsonl(eval_dir / "predictions.jsonl")
    metrics = load_json(eval_dir / "metrics.json")
    episode_manifest = load_json(episode_manifest_path)
    episodes = {episode.get("episode_id"): episode for episode in episode_manifest.get("episodes", [])}

    overall = empty_bucket()
    by_episode: dict[str, dict[str, Any]] = defaultdict(empty_bucket)
    by_family: dict[str, dict[str, Any]] = defaultdict(empty_bucket)
    by_seen: dict[str, dict[str, Any]] = defaultdict(empty_bucket)
    by_modality: dict[str, dict[str, Any]] = defaultdict(empty_bucket)
    by_object_category: dict[str, dict[str, Any]] = defaultdict(empty_bucket)
    invalid_examples = []
    overgenerated_examples = []
    modality_missing_by_episode: dict[str, list[str]] = {}

    for row in predictions:
        episode_id = str(row.get("episode_id"))
        true_json = row.get("true_json") or {}
        pred_json = row.get("pred_json") or {}
        add_row_stats(overall, row)
        add_row_stats(by_episode[episode_id], row)
        add_row_stats(by_family[family_for(str(true_json.get("action")), ACTION_FAMILIES)], row)
        add_row_stats(by_seen["seen_in_train" if row.get("true_label_seen_in_train") else "unseen_in_train"], row)
        state, missing = modality_state(episodes.get(episode_id))
        modality_missing_by_episode.setdefault(episode_id, missing)
        add_row_stats(by_modality[state], row)
        for category in object_categories(true_json.get("objects", [])):
            add_row_stats(by_object_category[category], row)
        if not pred_json and len(invalid_examples) < args.max_examples:
            invalid_examples.append({
                "id": row.get("id"),
                "episode_id": episode_id,
                "true_action": true_json.get("action"),
                "raw_prediction_prefix": str(row.get("raw_prediction", ""))[:240],
            })
        pred_objects = pred_json.get("objects", []) if isinstance(pred_json, dict) else []
        if len(pred_objects) > 20 and len(overgenerated_examples) < args.max_examples:
            overgenerated_examples.append({
                "id": row.get("id"),
                "episode_id": episode_id,
                "true_action": true_json.get("action"),
                "predicted_object_count": len(pred_objects),
                "first_predicted_objects": pred_objects[:20],
            })

    episode_rows = top_rows(by_episode)
    family_rows = top_rows(by_family)
    seen_rows = top_rows(by_seen)
    modality_rows = top_rows(by_modality)
    object_rows = top_rows(by_object_category)

    write_csv(output_dir / "episode_error_analysis.csv", episode_rows)
    write_csv(output_dir / "action_family_error_analysis.csv", family_rows)
    write_csv(output_dir / "train_seen_error_analysis.csv", seen_rows)
    write_csv(output_dir / "missing_modality_error_analysis.csv", modality_rows)
    write_csv(output_dir / "object_category_error_analysis.csv", object_rows)

    summary = {
        "status": "pass",
        "model_label": args.model_label,
        "source_package": package_dir.name,
        "source_eval_dir": public_path(eval_dir),
        "source_episode_manifest": public_path(episode_manifest_path),
        "source_prediction_rows": len(predictions),
        "metrics_json_validity_rate": metrics.get("json_validity_rate"),
        "computed": finalize_bucket("overall", overall),
        "worst_episode_groups": episode_rows[:8],
        "action_family_groups": family_rows,
        "train_seen_groups": seen_rows,
        "missing_modality_groups": modality_rows,
        "object_category_groups": object_rows,
        "invalid_json_examples": invalid_examples,
        "object_overgeneration_examples": overgenerated_examples,
        "modality_missing_by_episode": modality_missing_by_episode,
        "interpretation": (
            "The diagnostic pilot is dominated by invalid or weak structured outputs and exact-label failures. "
            "These tables identify where to tighten JSON constraints, action/subtask target formatting, object vocabularies, "
            "and missing-modality robustness before presenting stronger model quality."
        ),
    }
    (output_dir / "error_analysis_summary.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")

    report = [
        f"# {args.model_label} Held-Out Error Analysis",
        "",
        "This report is computed from public-safe predictions and an episode manifest. It contains only derived metrics and sanitized examples.",
        "",
        "## Overall",
        "",
        f"- Prediction rows: `{len(predictions)}`",
        f"- JSON validity from `metrics.json`: `{summary['metrics_json_validity_rate']:.4f}`",
        f"- Parsed prediction rate from public rows: `{summary['computed']['parsed_prediction_rate']:.4f}`",
        f"- Action exact rate: `{summary['computed']['action_exact_rate']:.4f}`",
        f"- Subtask exact rate: `{summary['computed']['subtask_exact_rate']:.4f}`",
        f"- Contact exact rate: `{summary['computed']['contact_exact_rate']:.4f}`",
        f"- Object F1: `{summary['computed']['object_f1']:.4f}`",
        "",
        "## Weakest Episode Groups",
        "",
        *markdown_table(episode_rows, ["group", "samples", "parsed_prediction_rate", "action_exact_rate", "object_f1"]),
        "",
        "## Action Families",
        "",
        *markdown_table(family_rows, ["group", "samples", "parsed_prediction_rate", "action_exact_rate", "subtask_exact_rate", "object_f1"]),
        "",
        "## Train-Seen Split",
        "",
        *markdown_table(seen_rows, ["group", "samples", "parsed_prediction_rate", "action_exact_rate", "next_action_exact_rate"]),
        "",
        "## Required-Modality State",
        "",
        *markdown_table(modality_rows, ["group", "samples", "parsed_prediction_rate", "action_exact_rate", "object_f1"]),
        "",
        "## Object Categories",
        "",
        *markdown_table(object_rows, ["group", "samples", "object_precision", "object_recall", "object_f1"]),
        "",
        "## Interpretation",
        "",
        summary["interpretation"],
        "",
        "Generated files:",
        "",
        "- `error_analysis_summary.json`",
        "- `episode_error_analysis.csv`",
        "- `action_family_error_analysis.csv`",
        "- `train_seen_error_analysis.csv`",
        "- `missing_modality_error_analysis.csv`",
        "- `object_category_error_analysis.csv`",
    ]
    (output_dir / "ERROR_ANALYSIS.md").write_text("\n".join(report) + "\n", encoding="utf-8")
    print(json.dumps({"status": "pass", "output_dir": str(output_dir), "prediction_rows": len(predictions)}, indent=2))
    return 0


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