Upload residual heatmap guide asset: build_object_requirement_credit_payloads.py

Reward_finetuning/SAGE-GRPO/scripts/build_object_requirement_credit_payloads.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""Build renderer payloads from saved rl_samples reward JSON files.
+
+The visualization renderer expects records shaped like the rerun VLM JSONL
+payloads: a ``source`` block plus a ``rerun_record`` containing ``credit_map``.
+Training ``*_rewards.json`` files save the same credit maps, but nested under
+per-sample reward records. This script converts those saved records into a
+JSONL pool and filters for object-specific questions.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import re
+from pathlib import Path
+from typing import Dict, Iterable, List, Sequence, Tuple
+
+from select_spatial_two_object_credit_examples import (
+    object_count,
+    normalize_text,
+    spatial_prompt_score,
+)
+
+
+DEFAULT_EXCLUDE_MANIFESTS = (
+    "outputs/rerun_vlm_same_gradient_window_smoothing/spatial_two_object_credit_examples_500_filled/candidate_manifest.csv",
+    "outputs/rerun_vlm_same_gradient_window_smoothing/spatial_two_object_credit_examples_500/candidate_manifest.csv",
+    "outputs/rerun_vlm_same_gradient_window_smoothing/spatial_two_object_credit_examples_selected_12/selected_manifest.csv",
+)
+
+QUESTION_EXCLUDE_PATTERNS = re.compile(
+    r"\b("
+    r"camera|shot|view|static|handheld|pans?|tilts?|zooms?|slow[- ]motion|"
+    r"motion blur|fade|lighting|style|anime|cinematic|close[- ]up|level angle"
+    r")\b",
+    re.I,
+)
+
+QUESTION_JSON_RE = re.compile(r'"question"\s*:\s*"((?:\\.|[^"\\])*)"')
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--repo-root",
+        type=Path,
+        default=Path.cwd(),
+        help="SAGE-GRPO repository root. Relative paths are resolved from here.",
+    )
+    parser.add_argument(
+        "--rl-samples-root",
+        type=Path,
+        default=Path("outputs/yw006-4-sage-qwen35-9b-token-credit-video-adv-window3/rl_samples"),
+        help="Directory containing step/group/*_rewards.json files.",
+    )
+    parser.add_argument("--output-jsonl", type=Path, required=True)
+    parser.add_argument("--manifest-csv", type=Path, required=True)
+    parser.add_argument(
+        "--exclude-manifest",
+        type=Path,
+        action="append",
+        default=[],
+        help="Candidate/selected manifest whose step/group/sample_idx/question_id keys should be excluded.",
+    )
+    parser.add_argument("--use-default-excludes", action="store_true")
+    parser.add_argument("--min-question-object-count", type=int, default=1)
+    parser.add_argument("--min-prompt-object-count", type=int, default=2)
+    parser.add_argument(
+        "--top-k",
+        type=int,
+        default=0,
+        help="If positive, write only the top K records by object/spatial prompt score.",
+    )
+    return parser.parse_args()
+
+
+def resolve_path(repo_root: Path, path: Path) -> Path:
+    return path if path.is_absolute() else repo_root / path
+
+
+def manifest_key(row: Dict[str, str]) -> Tuple[str, str, str, str]:
+    return (
+        str(row.get("step", "")),
+        str(row.get("group", "")),
+        str(row.get("sample_idx", "")),
+        str(row.get("question_id", "")),
+    )
+
+
+def load_excluded_keys(paths: Sequence[Path]) -> set[Tuple[str, str, str, str]]:
+    keys: set[Tuple[str, str, str, str]] = set()
+    for path in paths:
+        if not path.exists():
+            continue
+        with path.open("r", encoding="utf-8", newline="") as f:
+            for row in csv.DictReader(f):
+                keys.add(manifest_key(row))
+    return keys
+
+
+def extract_atomic_question(full_prompt: object, question_id: object) -> str:
+    text = str(full_prompt or "")
+    qid = str(question_id or "")
+    for line in text.splitlines():
+        if f'"id": "{qid}"' not in line and f'"id":"{qid}"' not in line:
+            continue
+        match = QUESTION_JSON_RE.search(line)
+        if match:
+            return json.loads(f'"{match.group(1)}"')
+    match = QUESTION_JSON_RE.search(text)
+    if match:
+        return json.loads(f'"{match.group(1)}"')
+    return normalize_text(text)
+
+
+def has_credit_map(record: Dict) -> bool:
+    values = record.get("credit_map")
+    shape = record.get("credit_map_shape")
+    if not isinstance(values, list) or not isinstance(shape, list) or len(shape) != 3:
+        return False
+    try:
+        expected = int(shape[0]) * int(shape[1]) * int(shape[2])
+    except Exception:
+        return False
+    return len(values) == expected
+
+
+def reward_json_files(root: Path) -> Iterable[Path]:
+    yield from sorted(root.rglob("*_rewards.json"))
+
+
+def read_reward_file(path: Path) -> List[Dict]:
+    with path.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+    if not isinstance(data, list):
+        raise ValueError(f"expected list in {path}")
+    return data
+
+
+def candidate_sort_key(item: Dict) -> Tuple[float, int, int, str, str, str, str]:
+    source = item["payload"]["source"]
+    prompt = normalize_text(source.get("prompt", ""))
+    question = normalize_text(source.get("question", ""))
+    spatial_score, _phrase_type, _obj_count = spatial_prompt_score(prompt, question)
+    return (
+        float(spatial_score),
+        int(item["prompt_object_count"]),
+        int(item["question_object_count"]),
+        str(source.get("step", "")),
+        str(source.get("group", "")),
+        str(source.get("sample_idx", "")),
+        str(source.get("question_id", "")),
+    )
+
+
+def main() -> None:
+    args = parse_args()
+    repo_root = args.repo_root.resolve()
+    rl_samples_root = resolve_path(repo_root, args.rl_samples_root)
+    output_jsonl = resolve_path(repo_root, args.output_jsonl)
+    manifest_csv = resolve_path(repo_root, args.manifest_csv)
+
+    exclude_paths = [resolve_path(repo_root, path) for path in args.exclude_manifest]
+    if args.use_default_excludes:
+        exclude_paths.extend(resolve_path(repo_root, Path(path)) for path in DEFAULT_EXCLUDE_MANIFESTS)
+    excluded = load_excluded_keys(exclude_paths)
+
+    scanned_records = 0
+    has_map = 0
+    object_q = 0
+    excluded_prev = 0
+    candidates: List[Dict] = []
+
+    for reward_path in reward_json_files(rl_samples_root):
+        step = reward_path.parent.parent.name
+        group = reward_path.parent.name
+        try:
+            samples = read_reward_file(reward_path)
+        except Exception as exc:
+            print(f"skip unreadable {reward_path}: {exc}", flush=True)
+            continue
+        for sample in samples:
+            if not isinstance(sample, dict):
+                continue
+            prompt = normalize_text(sample.get("prompt", ""))
+            prompt_obj_count = object_count(prompt)
+            for record in sample.get("reward_records", []):
+                if not isinstance(record, dict):
+                    continue
+                scanned_records += 1
+                if not has_credit_map(record):
+                    continue
+                has_map += 1
+
+                qid = str(record.get("question_id", ""))
+                atomic_question = extract_atomic_question(record.get("question", ""), qid)
+                question_obj_count = object_count(atomic_question)
+                if question_obj_count < args.min_question_object_count:
+                    continue
+                if prompt_obj_count < args.min_prompt_object_count:
+                    continue
+                if QUESTION_EXCLUDE_PATTERNS.search(atomic_question):
+                    continue
+                object_q += 1
+
+                key = (str(step), str(group), str(sample.get("sample_idx", "")), qid)
+                if key in excluded:
+                    excluded_prev += 1
+                    continue
+
+                payload = {
+                    "source": {
+                        "step": step,
+                        "group": group,
+                        "sample_idx": sample.get("sample_idx"),
+                        "question_id": qid,
+                        "prompt": prompt,
+                        "question": atomic_question,
+                        "target_answer": record.get("target_answer"),
+                        "source_pred": record.get("pred_sentence"),
+                        "video_path": sample.get("video_path"),
+                        "reward_json_path": str(reward_path),
+                    },
+                    "rerun_record": record,
+                }
+                candidates.append(
+                    {
+                        "payload": payload,
+                        "reward_json_path": str(reward_path),
+                        "prompt_object_count": prompt_obj_count,
+                        "question_object_count": question_obj_count,
+                    }
+                )
+
+    candidates.sort(key=candidate_sort_key, reverse=True)
+    if args.top_k > 0:
+        candidates = candidates[: args.top_k]
+
+    output_jsonl.parent.mkdir(parents=True, exist_ok=True)
+    manifest_csv.parent.mkdir(parents=True, exist_ok=True)
+
+    with output_jsonl.open("w", encoding="utf-8") as f:
+        for item in candidates:
+            f.write(json.dumps(item["payload"], ensure_ascii=False) + "\n")
+
+    fieldnames = [
+        "step",
+        "group",
+        "sample_idx",
+        "question_id",
+        "prompt_object_count",
+        "question_object_count",
+        "target_answer",
+        "source_pred",
+        "question",
+        "prompt",
+        "video_path",
+        "reward_json_path",
+    ]
+    with manifest_csv.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for item in candidates:
+            source = item["payload"]["source"]
+            writer.writerow(
+                {
+                    "step": source.get("step"),
+                    "group": source.get("group"),
+                    "sample_idx": source.get("sample_idx"),
+                    "question_id": source.get("question_id"),
+                    "prompt_object_count": item["prompt_object_count"],
+                    "question_object_count": item["question_object_count"],
+                    "target_answer": source.get("target_answer"),
+                    "source_pred": source.get("source_pred"),
+                    "question": source.get("question"),
+                    "prompt": source.get("prompt"),
+                    "video_path": source.get("video_path"),
+                    "reward_json_path": item["reward_json_path"],
+                }
+            )
+
+    print(
+        " ".join(
+            [
+                f"scanned={scanned_records}",
+                f"has_map={has_map}",
+                f"object_q={object_q}",
+                f"excluded_prev={excluded_prev}",
+                f"written={len(candidates)}",
+            ]
+        )
+    )
+    print(output_jsonl)
+    print(manifest_csv)
+
+
+if __name__ == "__main__":
+    main()