Add reproducible SPARC release filtering script

export_sparc_training_subset.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Materialize the exact SPARC VQA subset used by the released models."""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import json
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+VACANT_TASK_TYPES = {"vacant_goal", "vacant_start"}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("input", type=Path, help="Raw SPARC VQA Parquet file")
+    parser.add_argument("output", type=Path, help="Filtered output Parquet file")
+    parser.add_argument("--quality-threshold", type=float, default=0.97)
+    parser.add_argument("--max-per-object", type=int, default=700)
+    parser.add_argument("--blocked-vacant-location", action="append")
+    return parser.parse_args()
+
+
+def trajectory_key(source: str | None, row_metadata: dict) -> str:
+    return "::".join(
+        (
+            source or "",
+            str(row_metadata.get("trajectory_name") or ""),
+            str(row_metadata.get("subtask_index") or ""),
+        )
+    )
+
+
+def object_name(row_metadata: dict) -> str:
+    task_object = row_metadata.get("task_obj_info") or {}
+    if isinstance(task_object, dict):
+        value = task_object.get("object") or row_metadata.get("object_phrase") or ""
+    else:
+        value = row_metadata.get("object_phrase") or ""
+    return str(value).strip().lower() or "<unknown>"
+
+
+def vacant_location(row_metadata: dict, task_type: str) -> str:
+    location_key = "target_location" if task_type == "vacant_goal" else "start_location"
+    task_object = row_metadata.get("task_obj_info") or {}
+    if isinstance(task_object, dict):
+        return str(task_object.get(location_key) or "")
+    return ""
+
+
+def is_blocked_vacant(row_metadata: dict, task_type: str, blocked_keywords: list[str]) -> bool:
+    if task_type not in VACANT_TASK_TYPES:
+        return False
+    location = vacant_location(row_metadata, task_type).lower()
+    return any(keyword in location for keyword in blocked_keywords)
+
+
+def main() -> None:
+    args = parse_args()
+    blocked_keywords = [keyword.lower() for keyword in (args.blocked_vacant_location or ["gripper"])]
+    parquet = pq.ParquetFile(args.input)
+    candidates: list[tuple[float, int, int, str, dict, str]] = []
+
+    for row_group_index in range(parquet.metadata.num_row_groups):
+        table = parquet.read_row_group(row_group_index, columns=["metadata", "source", "task_type"])
+        metadata_column = table["metadata"].to_pylist()
+        source_column = table["source"].to_pylist()
+        task_type_column = table["task_type"].to_pylist()
+        for row_index, (metadata_string, source, task_type) in enumerate(
+            zip(metadata_column, source_column, task_type_column)
+        ):
+            row_metadata = json.loads(metadata_string or "{}")
+            selected_score = float(row_metadata.get("selected_start_score") or 0.0)
+            if selected_score >= args.quality_threshold:
+                candidates.append(
+                    (selected_score, row_group_index, row_index, source, row_metadata, task_type)
+                )
+        print(
+            f"Scanned row group {row_group_index + 1}/{parquet.metadata.num_row_groups}; "
+            f"{len(candidates):,} examples pass the score threshold",
+            flush=True,
+        )
+
+    candidates.sort(key=lambda candidate: candidate[0], reverse=True)
+
+    kept_trajectories: set[str] = set()
+    object_counts: collections.Counter[str] = collections.Counter()
+    for _, _, _, source, row_metadata, _ in candidates:
+        key = trajectory_key(source, row_metadata)
+        if key in kept_trajectories:
+            continue
+        name = object_name(row_metadata)
+        if object_counts[name] < args.max_per_object:
+            kept_trajectories.add(key)
+            object_counts[name] += 1
+
+    selected_by_row_group: dict[int, list[int]] = collections.defaultdict(list)
+    for _, row_group_index, row_index, source, row_metadata, task_type in candidates:
+        if trajectory_key(source, row_metadata) in kept_trajectories and not is_blocked_vacant(
+            row_metadata, task_type, blocked_keywords
+        ):
+            selected_by_row_group[row_group_index].append(row_index)
+
+    selected_count = sum(len(indices) for indices in selected_by_row_group.values())
+    output = args.output
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with pq.ParquetWriter(str(output), parquet.schema_arrow, compression="snappy") as writer:
+        for row_group_index in range(parquet.metadata.num_row_groups):
+            row_indices = selected_by_row_group.get(row_group_index)
+            if not row_indices:
+                continue
+            table = parquet.read_row_group(row_group_index)
+            writer.write_table(table.take(pa.array(row_indices, type=pa.int64())))
+            print(
+                f"Wrote row group {row_group_index + 1}/{parquet.metadata.num_row_groups}; "
+                f"{len(row_indices):,} selected examples",
+                flush=True,
+            )
+
+    print(
+        f"Wrote {selected_count:,} examples to {output} using score >= {args.quality_threshold}, "
+        f"max {args.max_per_object} trajectories per object, and blocked vacant locations {blocked_keywords}",
+        flush=True,
+    )
+
+
+if __name__ == "__main__":
+    main()