Datasets:
File size: 3,798 Bytes
bf74cb5 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 | #!/usr/bin/env python
"""Stream the Transitions view: before, action, after.
python examples/stream_transitions.py --root . --split train --limit 2000
A screenshot is stored **once**. A transition names its two endpoints by key,
so the loader pairs them; it never stores both images in a row. Because a whole
episode is packed into one shard, both endpoints of every transition are in the
shard already open - pair first, then shuffle at sample level, and the pairing
costs no extra I/O.
`transition_train_eligible` is not the same flag as `state_train_eligible`. A
transition whose action changed nothing is **kept** - it is negative
supervision - while the resulting state is excluded from the States view.
"""
from __future__ import annotations
import argparse
import collections
import sys
import time
from pathlib import Path
import pyarrow.parquet as pq
sys.path.insert(0, str(Path(__file__).resolve().parent))
from _common import decode, iter_tar, shards_for # noqa: E402
def main() -> int:
ap = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--root", default=".")
ap.add_argument("--split", default="train")
ap.add_argument("--limit", type=int, default=2000)
ap.add_argument("--eligible-only", action="store_true", default=True)
ap.add_argument("--decode-images", action="store_true")
args = ap.parse_args()
root = Path(args.root)
table = pq.read_table(
root / "index" / "transitions" / ("%s.parquet" % args.split),
columns=["before_key", "after_key", "action_type", "action_point_px",
"action_target_role", "action_target_text", "effect",
"transition_train_eligible"]).to_pydict()
by_before: dict = collections.defaultdict(list)
for index, before in enumerate(table["before_key"]):
if args.eligible_only and not table["transition_train_eligible"][index]:
continue
by_before[before].append(index)
print("%s eligible transitions in %s" % ("{:,}".format(sum(
len(v) for v in by_before.values())), args.split))
pairs = 0
changed = 0
roles: collections.Counter = collections.Counter()
started = time.time()
for shard in shards_for(root, args.split):
# One pass per shard: hold only the states this shard's transitions need.
held: dict = {}
wanted_after: dict = collections.defaultdict(list)
for sample in iter_tar(shard):
key = sample["__key__"]
item = decode(sample, with_image=args.decode_images)
if key in by_before:
held[key] = item
for index in by_before[key]:
wanted_after[table["after_key"][index]].append((key, index))
for before_key, index in wanted_after.pop(key, []):
before = held.get(before_key)
if before is None:
continue
pairs += 1
changed += bool(table["effect"][index]["changed"])
roles[table["action_target_role"][index]] += 1
if pairs >= args.limit:
break
if pairs >= args.limit:
break
if pairs >= args.limit:
break
seconds = time.time() - started
print("%s transitions paired in %.1fs (%.0f/s)"
% ("{:,}".format(pairs), seconds, pairs / max(seconds, 1e-9)))
print("changed something: %.1f%% no-op: %.1f%%"
% (100.0 * changed / max(pairs, 1), 100.0 * (pairs - changed) / max(pairs, 1)))
print("clicked roles: %s" % ", ".join("%s %d" % pair for pair in roles.most_common(8)))
return 0
if __name__ == "__main__":
raise SystemExit(main())
|