#!/usr/bin/env python3 """Build a unified 20-task radar chart for baseline and model-branch metrics.""" from __future__ import annotations import html import json import math from datetime import datetime, timezone from pathlib import Path from typing import Any ROOT = Path(__file__).resolve().parents[1] TASK_SUITE_PATH = ROOT / "docs/data/task_suite_20.json" QWEN_V6_METRICS_PATH = ( ROOT / "results/omni_finetune/verified_public" / "xperience10m_qwen3_omni_128ep_multiscale_cap96_v6_rank64_lr5e5_full8gpu_lora_eval_test_full" / "eval/metrics.json" ) COSMOS_SUPER_REASONER_METRICS_PATH = ( ROOT / "results/omni_finetune/verified_public" / "xperience10m_cosmos3_super_reasoner_128ep_test_full_20260607" / "eval/metrics.json" ) COSMOS_NANO_METRICS_PATH = ( ROOT / "results/omni_finetune/verified_public" / "xperience10m_cosmos3_nano_128ep_future_window_h5_compat_adapter_eval_test_full" / "eval/metrics.json" ) COSMOS_SUPER_FD_METRICS_PATH = ( ROOT / "results/omni_finetune/verified_public" / "xperience10m_cosmos3_super_forward_dynamics_lora_128ep_train1epoch_256_attn_full8gpu_20260608_eval_test_full_fsdp" / "eval/metrics.json" ) OUTPUT_JSON = ROOT / "docs/data/unified_task_model_radar.json" OUTPUT_SVG = ROOT / "docs/assets/charts/unified_task_model_radar.svg" SERIES = { "minimal": { "label": "Minimal", "short_label": "Min", "color": "#ccffa0", "kind": "full_20_task_baseline", "scope": "1 public sample episode", "stroke_dasharray": None, }, "neural_mlp": { "label": "Neural MLP", "short_label": "NN", "color": "#67e8d1", "kind": "full_20_task_baseline", "scope": "1 public sample episode", "stroke_dasharray": None, }, "qwen3_omni_v6_lora": { "label": "Qwen3-Omni v6 LoRA", "short_label": "Qwen3", "color": "#9bb8ff", "kind": "partial_128_episode_foundation_model_overlay", "scope": "128 selected episodes, held-out test", "stroke_dasharray": "7 7", }, "cosmos3_super_reasoner": { "label": "Cosmos3-Super Reasoner", "short_label": "C3-S", "color": "#ff9c7a", "kind": "partial_128_episode_foundation_model_overlay", "scope": "128 selected episodes, held-out test", "stroke_dasharray": "4 7", }, "cosmos3_nano_future_window": { "label": "Cosmos3-Nano Future Window", "short_label": "C3-N", "color": "#d9c7ff", "kind": "partial_128_episode_world_model_overlay", "scope": "128 selected episodes, held-out test", "stroke_dasharray": "2 7", }, } FOUNDATION_TASK_METRICS = { "timeline_action": { "qwen3_omni_v6_lora": "action_macro_f1", "cosmos3_super_reasoner": "action_macro_f1", "cosmos3_nano_future_window": "action_accuracy_from_retrieved_future", }, "timeline_subtask": { "qwen3_omni_v6_lora": "subtask_accuracy", "cosmos3_super_reasoner": "subtask_accuracy", }, "transition_detection": { "qwen3_omni_v6_lora": "transition_accuracy", "cosmos3_super_reasoner": "transition_accuracy", "cosmos3_nano_future_window": "transition_accuracy", }, "next_action": { "qwen3_omni_v6_lora": "next_action_accuracy", "cosmos3_super_reasoner": "next_action_accuracy", "cosmos3_nano_future_window": "action_accuracy_from_retrieved_future", }, "contact_prediction": { "qwen3_omni_v6_lora": "contact_accuracy", "cosmos3_super_reasoner": "contact_accuracy", "cosmos3_nano_future_window": "contact_accuracy", }, "object_relevance": { "qwen3_omni_v6_lora": "object_micro_f1", "cosmos3_super_reasoner": "object_micro_f1", }, "cross_modal_retrieval": { "cosmos3_nano_future_window": "future_retrieval_mrr", }, } SHORT_TASK_LABELS = { "timeline_action": "Action", "timeline_subtask": "Step", "transition_detection": "Boundary", "next_action": "Next act", "hand_trajectory_forecast": "Hand traj", "contact_prediction": "Contact", "object_relevance": "Objects", "caption_grounding": "Language", "cross_modal_retrieval": "X-modal", "modality_reconstruction": "Recon", "temporal_order": "Order", "misalignment_detection": "Sync", "long_horizon_next_action": "Long act", "next_subtask_forecast": "Long step", "interaction_text_prediction": "Interact txt", "action_object_relation": "Act+obj", "object_set_forecast": "Future obj", "imu_to_hand_pose": "IMU->hand", "camera_view_sync_retrieval": "Cam sync", "time_to_transition": "Time2bdry", } def read_json(path: Path) -> dict[str, Any]: return json.loads(path.read_text(encoding="utf-8")) if path.exists() else {} def clamp01(value: float) -> float: return max(0.0, min(1.0, value)) def score_from_raw(value: float | None, direction: str, best_lower: float | None = None) -> float | None: if value is None: return None if direction == "lower": if value <= 0: return 1.0 if best_lower is None or best_lower <= 0: return None return clamp01(best_lower / value) return clamp01(value) def format_metric(value: float | None) -> str: if value is None: return "n/a" if abs(value) >= 10: return f"{value:.2f}" if abs(value) >= 1: return f"{value:.3f}" return f"{value:.4f}" def point(cx: float, cy: float, radius: float, angle: float) -> tuple[float, float]: return cx + math.cos(angle) * radius, cy + math.sin(angle) * radius def svg_text( x: float, y: float, text: str, *, size: int = 16, fill: str = "#f4f8ef", anchor: str = "start", weight: int | str = 600, opacity: float = 1.0, ) -> str: return ( f'{html.escape(text)}' ) def polyline(points: list[tuple[float, float]], *, fill: str, stroke: str, opacity: float, stroke_width: float, dash: str | None = None) -> str: coords = " ".join(f"{x:.1f},{y:.1f}" for x, y in points) dash_attr = f' stroke-dasharray="{dash}"' if dash else "" return ( f'' ) def build_payload() -> dict[str, Any]: suite = read_json(TASK_SUITE_PATH) qwen = read_json(QWEN_V6_METRICS_PATH) cosmos_super = read_json(COSMOS_SUPER_REASONER_METRICS_PATH) cosmos_nano = read_json(COSMOS_NANO_METRICS_PATH) cosmos_fd = read_json(COSMOS_SUPER_FD_METRICS_PATH) foundation_metrics = { "qwen3_omni_v6_lora": qwen, "cosmos3_super_reasoner": cosmos_super, "cosmos3_nano_future_window": cosmos_nano, } tasks: list[dict[str, Any]] = [] for row in suite.get("tasks", []): values: dict[str, dict[str, Any]] = { "minimal": { "raw": row.get("minimal_primary_metric"), "metric_key": row.get("metric_key"), "source": row.get("artifact_sources", {}).get("minimal_metrics"), "scope": "single_episode_public_sample", }, "neural_mlp": { "raw": row.get("neural_primary_metric"), "metric_key": row.get("metric_key"), "source": row.get("artifact_sources", {}).get("neural_metrics"), "scope": "single_episode_public_sample", }, } for series_id, metric_key in FOUNDATION_TASK_METRICS.get(row["task_id"], {}).items(): raw = foundation_metrics.get(series_id, {}).get(metric_key) values[series_id] = { "raw": raw, "metric_key": metric_key, "source": str( { "qwen3_omni_v6_lora": QWEN_V6_METRICS_PATH, "cosmos3_super_reasoner": COSMOS_SUPER_REASONER_METRICS_PATH, "cosmos3_nano_future_window": COSMOS_NANO_METRICS_PATH, }[series_id].relative_to(ROOT) ), "scope": "multi_episode_128_partial_model_overlay", } lower_values = [ item["raw"] for item in values.values() if row.get("metric_direction") == "lower" and isinstance(item.get("raw"), (int, float)) and item["raw"] > 0 ] best_lower = min(lower_values) if lower_values else None for item in values.values(): item["normalized_score"] = score_from_raw(item.get("raw"), row.get("metric_direction", "higher"), best_lower) item["raw_text"] = format_metric(item.get("raw")) tasks.append( { "task_number": row["task_number"], "task_id": row["task_id"], "label": row.get("task_display_name", row["task_id"]), "short_label": SHORT_TASK_LABELS.get(row["task_id"], row["task_id"].replace("_", " ").title()), "origin": row.get("origin"), "metric_key": row.get("metric_key"), "metric_name": row.get("metric_name"), "metric_direction": row.get("metric_direction"), "values": values, } ) series_records = [] for series_id, spec in SERIES.items(): covered = sum(1 for task in tasks if task["values"].get(series_id, {}).get("normalized_score") is not None) series_records.append( { "id": series_id, **spec, "covered_task_count": covered, "coverage_fraction": covered / max(len(tasks), 1), } ) fd_loss = (cosmos_fd.get("loss_summary") or {}).get("mean") return { "title": "Unified 20-Task Model Radar", "status": "pass", "generated_at_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"), "task_count": len(tasks), "normalization_policy": { "higher_is_better": "bounded metrics are plotted directly on 0-1 axes after clipping to [0, 1]", "lower_is_better": "lower-error metrics are converted to best_observed_value / raw_value within the same task", "raw_values": "raw metric values, metric keys, and sources are retained in this JSON; the SVG is an overview, not a replacement for the metric table", "foundation_model_overlay": "Qwen3/Cosmos points are plotted only on task-aligned axes. Missing axes mean the public result does not evaluate that task contract.", }, "series": series_records, "tasks": tasks, "model_branch_cards": [ { "id": "qwen3_omni_v6_lora", "title": "Qwen3-Omni v6 LoRA", "status": "verified", "task_aligned_axes": SERIES["qwen3_omni_v6_lora"]["short_label"], "coverage": f"{next(item for item in series_records if item['id'] == 'qwen3_omni_v6_lora')['covered_task_count']}/20 task-aligned axes", "headline": f"JSON validity {format_metric(qwen.get('json_validity_rate'))}; action macro-F1 {format_metric(qwen.get('action_macro_f1'))}", "source": str(QWEN_V6_METRICS_PATH.relative_to(ROOT)), }, { "id": "cosmos3_super_reasoner", "title": "Cosmos3-Super Reasoner", "status": "verified_base_weight_eval", "coverage": f"{next(item for item in series_records if item['id'] == 'cosmos3_super_reasoner')['covered_task_count']}/20 task-aligned axes", "headline": f"JSON validity {format_metric(cosmos_super.get('json_validity_rate'))}; action macro-F1 {format_metric(cosmos_super.get('action_macro_f1'))}", "source": str(COSMOS_SUPER_REASONER_METRICS_PATH.relative_to(ROOT)), }, { "id": "cosmos3_nano_future_window", "title": "Cosmos3-Nano Future Window", "status": "verified_compatibility_eval", "coverage": f"{next(item for item in series_records if item['id'] == 'cosmos3_nano_future_window')['covered_task_count']}/20 task-aligned axes", "headline": f"future retrieval MRR {format_metric(cosmos_nano.get('future_retrieval_mrr'))}; transition accuracy {format_metric(cosmos_nano.get('transition_accuracy'))}", "source": str(COSMOS_NANO_METRICS_PATH.relative_to(ROOT)), }, { "id": "cosmos3_super_forward_dynamics_lora", "title": "Cosmos3-Super Forward-Dynamics LoRA", "status": "verified_finetuned_adapter", "coverage": "separate camera-pose proxy target, not plotted on the 20 task axes", "headline": f"test MSE {format_metric(fd_loss)} over 448 held-out rows", "source": str(COSMOS_SUPER_FD_METRICS_PATH.relative_to(ROOT)), }, ], } def render_svg(payload: dict[str, Any]) -> str: width, height = 1720, 1220 cx, cy, radius = 570, 585, 330 tasks = payload["tasks"] n = len(tasks) angles = [-math.pi / 2 + 2 * math.pi * i / n for i in range(n)] parts = [ f'', "", '', '', "", '', '', '', svg_text(70, 86, "Unified 20-Task Model Radar", size=34, weight=800), svg_text(70, 122, "Direction-aware normalized scores across the single-episode task suite, with Qwen3/Cosmos task-aligned overlays.", size=17, fill="#a5afa2", weight=560), svg_text(70, 156, "Filled polygons: same 20 public-sample tasks. Points: 128-episode model branches only where the public metric maps to that task.", size=15, fill="#a5afa2", weight=560), ] for level in range(1, 6): r = radius * level / 5 ring = [point(cx, cy, r, angle) for angle in angles] parts.append(polyline(ring, fill="none", stroke="#ccffa0", opacity=0, stroke_width=1.1)) parts[-1] = parts[-1].replace('fill="none" fill-opacity="0.000"', 'fill="none"').replace('stroke-opacity="0.92"', 'stroke-opacity="0.15"') parts.append(svg_text(cx + 8, cy - r + 4, f"{level / 5:.1f}", size=11, fill="#a5afa2", weight=600, opacity=0.75)) for task, angle in zip(tasks, angles): x, y = point(cx, cy, radius, angle) parts.append(f'') lx, ly = point(cx, cy, radius + 58, angle) anchor = "middle" if math.cos(angle) > 0.25: anchor = "start" elif math.cos(angle) < -0.25: anchor = "end" parts.append(svg_text(lx, ly - 7, f"{task['task_number']:02d}", size=11, fill="#ccffa0", anchor=anchor, weight=800, opacity=0.9)) parts.append(svg_text(lx, ly + 13, task["short_label"], size=12, fill="#dce8d7", anchor=anchor, weight=650)) for series_id in ("minimal", "neural_mlp"): spec = SERIES[series_id] points = [] for task, angle in zip(tasks, angles): score = task["values"].get(series_id, {}).get("normalized_score") points.append(point(cx, cy, radius * float(score or 0.0), angle)) parts.append(polyline(points, fill=spec["color"], stroke=spec["color"], opacity=0.18 if series_id == "minimal" else 0.16, stroke_width=4.2)) for x, y in points: parts.append(f'') for series_id in ("qwen3_omni_v6_lora", "cosmos3_super_reasoner", "cosmos3_nano_future_window"): spec = SERIES[series_id] for task, angle in zip(tasks, angles): score = task["values"].get(series_id, {}).get("normalized_score") if score is None: continue x, y = point(cx, cy, radius * float(score), angle) parts.append( f'' ) legend_x, legend_y = 1105, 210 parts.append(f'') parts.append(svg_text(legend_x, legend_y, "How to read it", size=24, weight=800)) parts.append(svg_text(legend_x, legend_y + 30, "Score radius is normalized by metric direction.", size=14, fill="#a5afa2", weight=560)) parts.append(svg_text(legend_x, legend_y + 52, "Raw values stay in unified_task_model_radar.json.", size=14, fill="#a5afa2", weight=560)) cursor = legend_y + 100 for record in payload["series"]: color = record["color"] parts.append(f'') if record["kind"].startswith("partial"): parts.append(f'') parts.append(svg_text(legend_x + 64, cursor, record["label"], size=16, weight=800)) parts.append(svg_text(legend_x + 64, cursor + 22, f"{record['covered_task_count']}/20 axes ยท {record['scope']}", size=12, fill="#a5afa2", weight=560)) cursor += 62 cursor += 16 parts.append(svg_text(legend_x, cursor, "Model branch notes", size=20, weight=800)) cursor += 32 for card in payload["model_branch_cards"]: parts.append(f'') parts.append(svg_text(legend_x + 16, cursor + 3, card["title"], size=14, weight=800)) parts.append(svg_text(legend_x + 16, cursor + 24, card["coverage"], size=11, fill="#a5afa2", weight=600)) parts.append(svg_text(legend_x + 16, cursor + 45, card["headline"], size=11, fill="#dce8d7", weight=600)) cursor += 92 table_y = 1090 parts.append(f'') parts.append(svg_text(96, table_y - 8, "Caveat", size=15, fill="#ccffa0", weight=800)) parts.append(svg_text(170, table_y - 8, "This chart compares normalized metric direction, not identical raw units.", size=14, fill="#dce8d7", weight=650)) parts.append(svg_text(170, table_y + 18, "Qwen3/Cosmos overlays use 128-episode held-out branches and are plotted only on semantically aligned task axes.", size=14, fill="#a5afa2", weight=560)) parts.append(svg_text(170, table_y + 44, "Cosmos3-Super forward-dynamics LoRA is kept as a branch card because its camera-pose proxy MSE is not one of the 20 task metrics.", size=14, fill="#a5afa2", weight=560)) parts.append("") return "\n".join(parts) + "\n" def main() -> int: payload = build_payload() OUTPUT_JSON.parent.mkdir(parents=True, exist_ok=True) OUTPUT_SVG.parent.mkdir(parents=True, exist_ok=True) OUTPUT_JSON.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") OUTPUT_SVG.write_text(render_svg(payload), encoding="utf-8") print(f"PASS: wrote {OUTPUT_JSON}") print(f"PASS: wrote {OUTPUT_SVG}") return 0 if __name__ == "__main__": raise SystemExit(main())