| """Read XField simulation frames from a downloaded dataset or a pinned public Hub revision.""" |
| from functools import lru_cache |
| import gzip |
| import hashlib |
| import io |
| import json |
| import os |
| from pathlib import Path |
| import tarfile |
| import tempfile |
|
|
| import numpy as np |
| import zstandard as zstd |
| from filelock import FileLock |
| from huggingface_hub import HfApi, hf_hub_download |
|
|
| REPO = 'KAS2003/xfield-sim-core' |
| SPLITS = ('fit', 'dev', 'paired_eval') |
| SENSORS = {'image_rgb', 'img', 'cube', 'depth', 'sem', 'K', 'T', 'steer'} |
|
|
| @lru_cache(maxsize=8) |
| def _tar(path, pid): |
| return tarfile.open(path, mode='r:') |
|
|
| class XFieldSim: |
| """New methods get separate input and target dictionaries. The test sensor files contain no GT.""" |
|
|
| def __init__(self, split='fit', *, revision=None, local_dir=None, cache_dir=None): |
| if split not in SPLITS: |
| raise ValueError(f'Unknown split {split!r}') |
| self.split = split |
| self.local_dir = Path(local_dir).resolve() if local_dir else None |
| self.cache = Path(cache_dir or os.environ.get('XFIELD_CACHE', Path.home()/'.cache/xfield-sim')) |
| if self.local_dir is None: |
| self.revision = HfApi(token=False).dataset_info( |
| REPO, revision=revision or 'refs/heads/main', expand=['sha']).sha |
| else: |
| self.revision = revision |
| with gzip.open(self.file('catalog/frames.jsonl.gz'), 'rt') as f: |
| self.rows = [r for line in f if (r := json.loads(line))['split'] == split] |
| with self.file(f'splits/{split}.txt').open() as f: |
| keys = [s.rstrip('\n') for s in f] |
| if keys != [r['key'] for r in self.rows] or len(set(keys)) != len(keys): |
| raise ValueError('Frame index does not match the split') |
| self.by_key = {r['key']:i for i,r in enumerate(self.rows)} |
|
|
| def __len__(self): |
| return len(self.rows) |
|
|
| def file(self, name): |
| if self.local_dir: |
| return self.local_dir/name |
| return Path(hf_hub_download(REPO, name, repo_type='dataset', revision=self.revision, token=False)) |
|
|
| def archive(self, name): |
| path = self.file(name) |
| if name.endswith('.tar.zst'): |
| |
| scope = self.revision or 'download-'+hashlib.sha256(str(self.local_dir).encode()).hexdigest()[:16] |
| unpacked = (self.cache/scope/name).with_suffix('') |
| unpacked.parent.mkdir(parents=True, exist_ok=True) |
| with FileLock(str(unpacked)+'.lock'): |
| if not unpacked.exists(): |
| with tempfile.NamedTemporaryFile(dir=unpacked.parent, delete=False) as out: |
| tmp = Path(out.name) |
| try: |
| with path.open('rb') as stream: |
| zstd.ZstdDecompressor().copy_stream(stream, out) |
| except BaseException: |
| tmp.unlink(missing_ok=True) |
| raise |
| tmp.replace(unpacked) |
| path = unpacked |
| return _tar(str(path), os.getpid()) |
|
|
| def read(self, index): |
| row = self.rows[self.by_key[index] if isinstance(index, str) else index] |
| ar = self.archive(row['shard']) |
| with ar.extractfile(row['member']) as member, np.load(io.BytesIO(member.read()), allow_pickle=False) as z: |
| sample = {k:z[k] for k in z.files} |
| if str(sample['key']) != row['key']: |
| raise ValueError('Prepared frame identity mismatch') |
| if self.split == 'fit': |
| with self.archive(row['radar']).extractfile(row['radar_member']) as member: |
| data = zstd.ZstdDecompressor().decompress(member.read()) |
| sample['cube'] = np.load(io.BytesIO(data), allow_pickle=False) |
| if 'img' in sample: |
| sample['image_rgb'] = sample.pop('img') |
| cube = sample['cube'] |
| if cube.shape != (512,25,64) or cube.dtype != np.complex64 or sample['image_rgb'].shape != (3,360,640): |
| raise ValueError('Invalid radar/RGB dimensions') |
| if self.split == 'fit' and bool(sample['dense_present']) != row['dense']: |
| raise ValueError('Dense supervision flag mismatch') |
| inputs = {k:v for k,v in sample.items() if k in SENSORS} |
| labels = {k:v for k,v in sample.items() if k not in SENSORS|{'key','route'}} |
| if self.split == 'paired_eval' and labels: |
| raise ValueError('Unexpected labels in test sensors') |
| return {'key':row['key'], 'route':str(sample.get('route',row['episode'])), 'inputs':inputs, 'targets':labels} |
|
|
| __getitem__ = read |
|
|
| def available_keys(self): |
| """Keys whose required shards exist at the selected revision or in the local download.""" |
| if self.local_dir: |
| exists = lambda name: (self.local_dir/name).is_file() |
| else: |
| files = set(HfApi(token=False).list_repo_files(REPO, repo_type='dataset', revision=self.revision)) |
| exists = files.__contains__ |
| return [r['key'] for r in self.rows if exists(r['shard']) and ('radar' not in r or exists(r['radar']))] |
|
|
| def xfield_sample(self,index): |
| """A fit/dev item accepted by XField_PredCore training.rgb_required.batchify.""" |
| if self.split == 'paired_eval': |
| raise ValueError('Use read() for paired test inference') |
| frame = self.read(index) |
| item = {**frame['inputs'], **frame['targets'], 'key':frame['key'], 'route':frame['route']} |
| rgb = item.pop('image_rgb').astype(np.float32)/255 |
| mean=np.array([.485,.456,.406], dtype=np.float32)[:,None,None] |
| std=np.array([.229,.224,.225], dtype=np.float32)[:,None,None] |
| item['image']=(rgb-mean)/std |
| item['dense'] = tuple(item.pop(n) for n in ('dense_sem','dense_height','dense_lane')) if bool(item.pop('dense_present')) else None |
| return item |
|
|
| def test_truth(self,index): |
| """Read the separately stored targets when scoring frozen test predictions.""" |
| if self.split != 'paired_eval': |
| raise ValueError('Test truth is available only for paired_eval') |
| row=self.rows[self.by_key[index] if isinstance(index,str) else index] |
| if not hasattr(self,'_vehicles'): |
| with gzip.open(self.file('test_labels/vehicles.jsonl.gz'),'rt') as f: |
| self._vehicles={r['key']:r for r in map(json.loads,f)} |
| out={'vehicles':self._vehicles[row['key']]} |
| if row['present']: |
| with tarfile.open(self.file('test_labels/scene_occupancy.tar.gz'),'r:gz') as ar: |
| with np.load(io.BytesIO(ar.extractfile(row['key']+'.npz').read()),allow_pickle=False) as z: |
| if str(z['key'])!=row['key']:raise ValueError('Test label identity mismatch') |
| shape=tuple(z['shape']);n=int(np.prod(shape)) |
| out['occupancy']={k:np.unpackbits(z[k])[:n].reshape(shape).astype(bool) for k in ('obs','any')} |
| return out |
|
|
|
|
