| |
| """Write a collection out in the layout the world model is trained from. |
| |
| Run against a collection root -- the directory holding ``<domain>/<task_id>/`` |
| -- and it walks every trajectory it finds. Nothing is read from a VM, so this |
| is safe to re-run and safe to run while collection continues elsewhere. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from pathlib import Path |
|
|
|
|
| def walked_to_the_end(trajectory: Path) -> bool: |
| """Whether every recorded step of this trajectory was reproduced. |
| |
| Read from the run summary rather than recomputed, because the summary is |
| what the collector concluded at the time and the pairs file cannot |
| distinguish "the recording had four steps and we walked four" from "the |
| recording had nine and we walked four". |
| """ |
|
|
| for summary in sorted(trajectory.glob("runs/*.json")): |
| try: |
| record = json.loads(summary.read_text(encoding="utf-8")) |
| except (OSError, ValueError): |
| continue |
| walked = record.get("validated_transition_count") |
| total = record.get("spine_action_count") |
| if isinstance(walked, int) and isinstance(total, int) and total > 0: |
| if record.get("priming_action_count", 0) > 0: |
| alignment = record.get("initial_alignment") |
| if alignment is None: |
| try: |
| state = json.loads( |
| (trajectory / "states" / "state_000" / "state.json") |
| .read_text(encoding="utf-8") |
| ) |
| alignment = state.get("priming") |
| except (OSError, ValueError): |
| alignment = None |
| if not isinstance(alignment, dict) or alignment.get("passed") is not True: |
| return False |
| return walked == total |
| return False |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--source", type=Path, required=True) |
| parser.add_argument("--destination", type=Path, required=True) |
| parser.add_argument("--repository", type=Path, default=Path(__file__).parent.parent) |
| parser.add_argument( |
| "--manifest", |
| type=Path, |
| action="append", |
| default=[], |
| help=( |
| "a manifest, for the task instruction each prompt needs. " |
| "Repeatable: a collection may draw on several archives." |
| ), |
| ) |
| parser.add_argument( |
| "--collection-mode", |
| default="", |
| help="fills `collection_mode` for rows collected before the field existed", |
| ) |
| parser.add_argument( |
| "--anchor-agent", |
| default="", |
| help=( |
| "what reached the states: `recording` for a replayed archive, or " |
| "the model that walked them, e.g. `OpenCUA-7B`" |
| ), |
| ) |
| parser.add_argument( |
| "--only-listed", |
| type=Path, |
| default=None, |
| help=( |
| "a file of `<domain>/<task_id>` lines; deliver only those. A " |
| "collection root accumulates -- Mode B keeps walking into the same " |
| "root for days -- so re-exporting all of it would republish " |
| "trajectories already shipped. This delivers the increment." |
| ), |
| ) |
| parser.add_argument( |
| "--full-spine-only", |
| action="store_true", |
| help=( |
| "deliver only trajectories walked end to end. A partial walk " |
| "stops where the desktop and the recording part company, and its " |
| "prompts carry a task instruction the trajectory never went on to " |
| "satisfy -- so the steps are true about the desktop and misleading " |
| "about the task. The collection keeps them either way; this " |
| "decides what leaves it." |
| ), |
| ) |
| parser.add_argument( |
| "--keep-duplicates", action="store_true", |
| help="Export every transition, including ones the dataset already " |
| "carries. Deduplication is on by default because a published " |
| "set that repeats itself overstates what was collected; this " |
| "exists for inspecting what would have been removed.") |
| args = parser.parse_args() |
|
|
| repository = args.repository.resolve() |
| if str(repository) not in sys.path: |
| sys.path.insert(0, str(repository)) |
| from guiwm_collector.dataset.export import ( |
| export_trajectory, scan_for_duplicates) |
| from guiwm_collector.dataset.dedup import Ledger |
|
|
| instructions: dict[str, str] = {} |
| |
| |
| |
| archive_name = "" |
| if len(args.manifest) == 1 and args.manifest[0].is_file(): |
| archive_name = str( |
| (json.loads(args.manifest[0].read_text(encoding="utf-8")).get( |
| "source_archive") or {}).get("name") or "" |
| ) |
| for source in args.manifest: |
| if not source.is_file(): |
| continue |
| manifest = json.loads(source.read_text(encoding="utf-8")) |
| for task in manifest.get("tasks", []): |
| path = task.get("task_config_path") |
| if not path or not Path(path).is_file(): |
| continue |
| config = json.loads(Path(path).read_text(encoding="utf-8")) |
| instructions[str(task["task_id"])] = str(config.get("instruction") or "") |
|
|
| wanted: set[str] | None = None |
| if args.only_listed: |
| wanted = {line.strip() for line in |
| args.only_listed.read_text(encoding="utf-8").splitlines() |
| if line.strip()} |
|
|
| |
| |
| |
| partial = 0 |
| selected: list[Path] = [] |
| for pairs in sorted(args.source.glob("*/*/pairs.jsonl")): |
| trajectory = pairs.parent |
| if wanted is not None and ( |
| f"{trajectory.parent.name}/{trajectory.name}" not in wanted): |
| continue |
| if args.full_spine_only and not walked_to_the_end(trajectory): |
| partial += 1 |
| continue |
| selected.append(trajectory) |
|
|
| ledger = None |
| if not args.keep_duplicates: |
| print(f"scanning {len(selected)} trajectories for duplicates...", flush=True) |
| ledger = scan_for_duplicates(selected, Ledger()) |
| counts = ledger.counts() |
| print(" " + " · ".join(f"{k} {v}" for k, v in counts.items()), flush=True) |
|
|
| total_steps = total_skipped = trajectories = 0 |
| total_deduplicated = 0 |
| for trajectory in selected: |
| task_id = trajectory.name |
| summary = export_trajectory( |
| source=trajectory, |
| destination=args.destination / trajectory.parent.name / task_id, |
| instruction=instructions.get(task_id, ""), |
| source_archive=archive_name, |
| collection_mode=args.collection_mode, |
| anchor_agent=args.anchor_agent, |
| ledger=ledger, |
| ) |
| trajectories += 1 |
| total_steps += summary.steps |
| total_skipped += summary.skipped |
| total_deduplicated += summary.deduplicated |
| print(f"{trajectory.parent.name}/{task_id}: {summary.steps} steps " |
| f"({summary.skipped} skipped, {summary.deduplicated} duplicate)", |
| flush=True) |
|
|
| print(f"\n{trajectories} trajectories, {total_steps} steps, " |
| f"{total_skipped} skipped, {total_deduplicated} deduplicated" |
| + (f", {partial} partial trajectories withheld" if partial else "") |
| + f" -> {args.destination}") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
