| |
| """Read LocateAnything records and image bytes with Megatron-Energon 7.4.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from pathlib import Path |
| from typing import Any, Mapping, Sequence |
|
|
| from megatron.energon import ( |
| Cooker, |
| DefaultTaskEncoder, |
| FileStore, |
| Sample, |
| WorkerConfig, |
| basic_sample_keys, |
| cooker, |
| edataclass, |
| get_savable_loader, |
| get_train_dataset, |
| stateless, |
| ) |
|
|
|
|
| @edataclass |
| class LocateAnythingSample(Sample): |
| """One spatial annotation and its encoded image bytes.""" |
|
|
| record: dict[str, Any] |
| image: bytes |
|
|
|
|
| def _record(sample: Mapping[str, Any]) -> dict[str, Any]: |
| payload = sample.get("json") |
| if isinstance(payload, Mapping): |
| record = dict(payload) |
| elif isinstance(payload, (bytes, bytearray, str)): |
| record = json.loads(payload) |
| else: |
| raise ValueError( |
| "Energon sample does not contain a mapping- or JSON-valued 'json' field" |
| ) |
| if not isinstance(record, dict): |
| raise ValueError("LocateAnything record must be a JSON object") |
| if set(record) != {"_source", "image", "query", "task_type"}: |
| raise ValueError("LocateAnything record schema mismatch") |
| return record |
|
|
|
|
| @stateless |
| def cook_locate_anything( |
| sample: dict[str, Any], **aux: FileStore |
| ) -> LocateAnythingSample: |
| record = _record(sample) |
| image = record["image"] |
| source = image["source"] |
| member_name = image["path"] |
| try: |
| store = aux[source] |
| except KeyError as error: |
| raise ValueError(f"annotation names unknown auxiliary source {source!r}") from error |
| encoded = store.get(member_name, sample) |
| return LocateAnythingSample( |
| **basic_sample_keys(sample), |
| record=record, |
| image=encoded, |
| ) |
|
|
|
|
| class LocateAnythingTaskEncoder( |
| DefaultTaskEncoder[ |
| LocateAnythingSample, |
| LocateAnythingSample, |
| LocateAnythingSample, |
| LocateAnythingSample, |
| ] |
| ): |
| """Minimal encoder; subclass its packing methods for model token budgets.""" |
|
|
| decoder = None |
|
|
| def __init__(self) -> None: |
| self.cookers = [Cooker(cook_locate_anything)] |
| super().__init__() |
|
|
| @stateless |
| def select_samples_to_pack( |
| self, samples: list[LocateAnythingSample] |
| ) -> list[list[LocateAnythingSample]]: |
| return [[sample] for sample in samples] |
|
|
| @stateless |
| def pack_selected_samples( |
| self, samples: list[LocateAnythingSample] |
| ) -> LocateAnythingSample: |
| if len(samples) != 1: |
| raise ValueError("the example encoder only supports singleton packs") |
| return samples[0] |
|
|
|
|
| def _parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "metadataset", |
| type=Path, |
| help="Root, dataset, or view-level metadataset.yaml.", |
| ) |
| parser.add_argument("--samples", type=int, default=3) |
| parser.add_argument("--workers", type=int, default=0) |
| parser.add_argument("--rank", type=int, default=0) |
| parser.add_argument("--world-size", type=int, default=1) |
| return parser |
|
|
|
|
| def main(argv: Sequence[str] | None = None) -> int: |
| args = _parser().parse_args(argv) |
| worker_config = WorkerConfig( |
| rank=args.rank, |
| world_size=args.world_size, |
| num_workers=args.workers, |
| ) |
| dataset = get_train_dataset( |
| args.metadataset, |
| split_part="train", |
| worker_config=worker_config, |
| batch_size=None, |
| max_samples_per_sequence=1, |
| shuffle_over_epochs_multiplier=1, |
| shuffle_buffer_size=None, |
| task_encoder=LocateAnythingTaskEncoder(), |
| repeat=False, |
| ) |
| loader = get_savable_loader(dataset) |
| for index, sample in enumerate(loader): |
| print( |
| json.dumps( |
| { |
| "sample": index, |
| "sample_id": sample.record["_source"]["sample_id"], |
| "task_type": sample.record["task_type"], |
| "image_bytes": len(sample.image), |
| }, |
| ensure_ascii=False, |
| sort_keys=True, |
| ) |
| ) |
| if index + 1 >= args.samples: |
| break |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
