Datasets:
Download code/exhibition_dataset/export.py from Heiheihaha17/MESH-Benchmark: direct link, hf CLI and curl.
- Browser
- Download file 20 kB
-
https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/exhibition_dataset/export.py
- Command line
-
hf download hf://datasets/Heiheihaha17/MESH-Benchmark/code/exhibition_dataset/export.py
-
curl -L -o export.py https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/exhibition_dataset/export.py
20 kB
| """Unified public inputs, private labels, edge/cloud and ablation correspondence.""" | |
| from __future__ import annotations | |
| import argparse | |
| from collections import Counter | |
| import copy | |
| import math | |
| from pathlib import Path | |
| import numpy as np | |
| from .common import * | |
| from .prompts import render, ablation_recipes | |
| from .ablations import group_manifest | |
| def transcript(source): | |
| return ' '.join(e['text'] for e in sorted(source['events'], key=lambda e:e['start_sample'])) | |
| def keyword_alternatives(episode, source): | |
| words = tokens(source['events'][0]['text']) | |
| result = [] | |
| for size in [1,2,3]: | |
| prefix = words[:size] | |
| if len(prefix) != size: | |
| continue | |
| matches = [h['entity_id'] for h in episode['humans'] if tokens(h['events'][0]['text'])[:size] == prefix] | |
| if matches == [source['entity_id']]: | |
| result.append(dict(wake_phrase=' '.join(prefix), word_count=size)) | |
| return result | |
| def region_at(point): | |
| return dict(min_xyz_m=[round(math.floor(float(v)*10)/10-.2,1) for v in point], | |
| max_xyz_m=[round(math.ceil(float(v)*10)/10+.2,1) for v in point]) | |
| def region_members(episode, region): | |
| lo, hi = np.array(region['min_xyz_m']), np.array(region['max_xyz_m']) | |
| members = [] | |
| for source in episode['humans']+episode.get('playback_sources',[]): | |
| point = np.array(source['initial_xyz_m']) | |
| inside = bool(np.all(point >= lo) and np.all(point < hi)) | |
| # Every point must be at least 20 cm from the nearest region face. | |
| boundary = float(np.min(np.minimum(point-lo,hi-point))) if inside else float(np.linalg.norm(np.maximum(np.maximum(lo-point,point-hi),0))) | |
| if boundary < .2-1e-9: | |
| return None | |
| if inside and source['entity_type']=='human': | |
| members.append(source['entity_id']) | |
| return members | |
| def negative_region(episode, room, rng): | |
| from dynamic_dataset.geometry import points_clear | |
| width, _, depth = room['room_size_m'] | |
| for _ in range(5000): | |
| point = [rng.uniform(-width/2+.7,width/2-.7), 1.5, rng.uniform(-depth/2+.7,depth/2-.7)] | |
| if not points_clear(point, room, .35): | |
| continue | |
| region = region_at(point) | |
| if region_members(episode, region) == []: | |
| return region | |
| raise ValueError('Cannot create an unambiguous empty region') | |
| def private_metadata(episode, group): | |
| private = copy.deepcopy(episode) | |
| times = [s/SR for s in grid(episode)] if episode['mode'] == 'dynamic' else [0.] | |
| for entity in private['humans'] + private['robots'] + private['playback_sources']: | |
| displacement = np.array(entity['displacement_m']) | |
| length = float(np.linalg.norm(displacement)) | |
| entity.update(is_moving=length>0, movement_distance_m=length, | |
| motion_direction_world=(displacement/length).tolist() if length else None, | |
| peak_speed_mps=1.875*length/entity['motion_duration_s'], | |
| positions_world_m=[[t]+position(entity,t).tolist() for t in times], | |
| velocities_world_mps=[[t]+velocity(entity,t).tolist() for t in times]) | |
| entity['relative_to_robots'] = {} | |
| for robot in episode['robots']: | |
| if robot['entity_id'] == entity['entity_id']: | |
| entity['relative_to_robots'][robot['entity_id']] = dict(same_entity=True) | |
| else: | |
| entity['relative_to_robots'][robot['entity_id']] = [dict(time_s=t, | |
| relative_position_world_m=(position(entity,t)-position(robot,t)).tolist(), | |
| **geometry(entity,robot,t)) for t in times] | |
| private['room_acoustic_configuration'] = dict(room_id=group['room_id'], | |
| asset_hashes=group['room_assets_sha256']) | |
| return private | |
| def queries_for(episode, group, prefixes, excluded, include_keywords=True): | |
| """Yield task, deployment, receivers, reference, query, answer, target, case.""" | |
| rids = [r['entity_id'] for r in episode['robots']] | |
| all_views = [(v['setting'],v['receiver_ids'],v['reference_robot_id']) for v in views(episode)] | |
| if episode['mode'] == 'dynamic': | |
| for robot in episode['robots']: | |
| yield ('DOA_TRAJECTORY','edge',[robot['entity_id']],robot['entity_id'], | |
| dict(human_source_count=len(episode['humans'])), | |
| dict(tracks=[dict(track_id=h['entity_id'],frames=frames(episode,h,robot,'doa_deg')) for h in episode['humans']]), | |
| 'all_humans',None) | |
| for human in episode['humans']: | |
| for robot in episode['robots']: | |
| cue = next(q for q in episode['geometry_audit']['range_queries'] | |
| if q['source_id']==human['entity_id'] and q['receiver_id']==robot['entity_id']) | |
| query = {k:v for k,v in cue.items() if k not in ['source_id','receiver_id']} | |
| yield ('RANGE_TRAJECTORY','edge',[robot['entity_id']],robot['entity_id'],query, | |
| dict(frames=frames(episode,human,robot,'distance_m')),human['entity_id'],None) | |
| yield ('TEXT_TRAJECTORY','cloud',rids,None,dict(transcript=transcript(human)), | |
| dict(frames=frames(episode,human)),human['entity_id'],None) | |
| else: | |
| for robot in episode['robots']: | |
| rid = robot['entity_id'] | |
| sources = episode['humans']+[s for s in episode['playback_sources'] if s['entity_id']!=rid] | |
| yield ('DOA','edge',[rid],rid,dict(source_count=len(sources)), | |
| [geometry(s,robot,0.)['doa_deg'] for s in sources],'all_speech',None) | |
| for human in episode['humans']: | |
| cue = next(q for q in episode['geometry_audit']['range_queries'] | |
| if q['source_id']==human['entity_id'] and q['receiver_id']==rid) | |
| g = geometry(human,robot,0.) | |
| yield ('RANGE','edge',[rid],rid,dict(azimuth_sector_deg=cue['initial_sector_deg']),g['distance_m'],human['entity_id'],None) | |
| yield ('TEXT_DOA','edge',[rid],rid,dict(transcript=transcript(human)),g['doa_deg'],human['entity_id'],None) | |
| yield ('DOA_ASR','edge',[rid],rid,dict(doa_deg=[round(v) for v in g['doa_deg']]),transcript(human),human['entity_id'],None) | |
| yield ('C1_SETLOC','cloud',rids,None,dict(human_source_count=len(episode['humans'])), | |
| [h['initial_xyz_m'] for h in episode['humans']],'all_humans',None) | |
| for human in episode['humans']: | |
| yield ('C3_TEXTLOC','cloud',rids,None,dict(transcript=transcript(human)),human['initial_xyz_m'],human['entity_id'],None) | |
| region = region_at(human['initial_xyz_m']) | |
| if region_members(episode,region) == [human['entity_id']]: | |
| yield ('C2_REGION_ASR','cloud',rids,None,dict(region=region),transcript(human),human['entity_id'],'unique_human') | |
| else: | |
| excluded.append(dict(episode_id=episode['episode_id'],task_id='C2_REGION_ASR', | |
| source_id=human['entity_id'],reason='20 cm region-face guard or unique target failed')) | |
| rng = np.random.default_rng(int(uid('negative-region',episode['episode_id']),16)%2**32) | |
| yield ('C2_REGION_ASR','cloud',rids,None,dict(region=negative_region(episode,group['room'],rng)),'','no_match','no_match') | |
| if not include_keywords: | |
| return | |
| keyword_queries = [] | |
| for index,human in enumerate(episode['humans']): | |
| alternatives = keyword_alternatives(episode,human) | |
| if not alternatives: | |
| excluded.append(dict(episode_id=episode['episode_id'],task_id='KW_ASR', | |
| source_id=human['entity_id'],reason='No unique 1/2/3-word human prefix')) | |
| continue | |
| desired = 1+(group['room_index']+index)%3 | |
| selected = min(alternatives,key=lambda a:abs(a['word_count']-desired)) | |
| keyword_queries.append((dict(wake_phrase=selected['wake_phrase']), | |
| transcript(human),human['entity_id'],'unique_human')) | |
| beginnings = [tokens(e['text']) for s in episode['humans']+episode['playback_sources'] for e in s['events']] | |
| absent = next(p for p in prefixes if not any(w[:len(tokens(p))]==tokens(p) for w in beginnings)) | |
| keyword_queries.append((dict(wake_phrase=absent),'','no_match','no_match')) | |
| robot_only = [] | |
| for source in episode['playback_sources']: | |
| for size in [1,2,3]: | |
| prefix = tokens(source['events'][0]['text'])[:size] | |
| if prefix and not any(tokens(h['events'][0]['text'])[:size]==prefix for h in episode['humans']): | |
| robot_only.append(' '.join(prefix)) | |
| if robot_only: | |
| keyword_queries.append((dict(wake_phrase=robot_only[0]),'','robot_only','robot_only')) | |
| for query,answer,target,case in keyword_queries: | |
| for setting,observed,reference in all_views: | |
| yield ('KW_ASR',setting,observed,None,query,answer,target,case) | |
| def export(root, mode, pilot=False, indices=None): | |
| root = root.resolve() | |
| destination = root/mode | |
| groups = [read(p) for p in sorted((root/'private/plans').glob('*.json'))] | |
| if pilot: | |
| groups = [g for g in groups if (destination/'reports/groups'/(g['group_id']+'.json')).exists()] | |
| if indices is not None: | |
| groups=[g for g in groups if g['index'] in indices] | |
| prefixes = sorted({' '.join(tokens(e['text'])[:3]) for g in groups for h in g['material_inventory'] | |
| if h['entity_type']=='human' for e in h['events']},key=lambda p:uid('absent-prefix',p)) | |
| data = {k:[] for k in ['scenes','episodes','recordings','views','inputs','prompts','gold','private_episodes','pairs','excluded','physical_pairs','keyword_variants','ablation_groups']} | |
| seen_halls = set() | |
| rooms={r['room_id']:r for r in rows(root/'private/rooms.jsonl')} | |
| for group in groups: | |
| report = read(destination/'reports/groups'/(group['group_id']+'.json')) | |
| if not report.get('final_normalization_applied') and not pilot: | |
| raise ValueError('Cannot publish unnormalized raw mixtures') | |
| recs = {(r['episode_id'],r['receiver_robot_id']):r for r in report['recordings']} | |
| if group['scene_id'] not in seen_halls: | |
| seen_halls.add(group['scene_id']) | |
| room = group['room'] | |
| acoustic=rooms[group['room_id']]['acoustic_check'] | |
| data['scenes'].append(dict(scene_id=group['scene_id'],room_id=group['room_id'], | |
| room_family_id=uid('room-family',group['room_assets_sha256']['geometry.glb']), | |
| environment='exhibition_hall',room_dimensions_m=[round(v,1) for v in room['room_size_m']], | |
| layout_template=room['template'],area_m2=room['area_m2'],area_bin=room['area_bin'],rt_bin=room['rt_bin'], | |
| measured_midfrequency_rt60_s=acoustic['room_midfrequency_rt60_median_s'], | |
| rt60_target_bin_s=acoustic['target_bin_s'],rt60_measurement_method=acoustic['method'], | |
| asset_directory='public/assets/rooms/'+group['room_id'],asset_hashes=group['room_assets_sha256'])) | |
| for episode in group[mode+'_episodes']: | |
| eid = episode['episode_id'] | |
| poses, played = robot_poses(episode),playback_log(episode) | |
| public = dict(schema_version=VERSION,scene_id=episode['scene_id'],episode_id=eid, | |
| episode_group_id=group['group_id'],condition_id=episode['condition_id'],mode=mode, | |
| duration_samples=episode['duration_samples'],sample_rate_hz=SR, | |
| label_step_s=.5 if mode=='dynamic' else None,scene_robot_ids=[r['entity_id'] for r in episode['robots']], | |
| known_robot_poses=poses,known_robot_playback=played,strict_sync=True,own_playback_policy='ideal_own_only') | |
| data['episodes'].append(public) | |
| private = private_metadata(episode,group) | |
| private['acoustic_measurements'] = [m for m in report['acoustic_measurements'] if m['episode_id']==eid] | |
| data['private_episodes'].append(private) | |
| data['recordings'].extend(r for r in report['recordings'] if r['episode_id']==eid) | |
| for view in views(episode): | |
| view['recording_ids'] = [recs[(eid,r)]['recording_id'] for r in view['receiver_ids']] | |
| data['views'].append(view) | |
| for task,setting,observed,reference,query,answer,target,case in queries_for(episode,group,prefixes,data['excluded']): | |
| nonce = group['evaluation_id_nonce'] | |
| query_group = uid(eid,'query',task,target,query,nonce) | |
| view_id = uid(eid,'view',setting,observed) | |
| sid = uid(eid,view_id,task,query_group) | |
| bindings = [dict(slot=i,robot_id=r,recording_id=recs[(eid,r)]['recording_id'], | |
| path=recs[(eid,r)]['path'],sha256=recs[(eid,r)]['sha256']) for i,r in enumerate(observed)] | |
| sample = dict(schema_version=VERSION,sample_id=sid,scene_id=episode['scene_id'],episode_id=eid, | |
| episode_group_id=group['group_id'],condition_id=episode['condition_id'],view_id=view_id, | |
| query_group_id=query_group,target_group_id=uid(eid,'target',target,nonce),task_id=task, | |
| setting=setting,mode=mode,receiver_ids=observed,reference_robot_id=reference, | |
| recording_ids=[b['recording_id'] for b in bindings],audio_bindings=bindings, | |
| query=query,duration_samples=episode['duration_samples'],time_window_samples=[0,episode['duration_samples']], | |
| sample_rate_hz=SR,label_step_samples=LABEL_STEP if mode=='dynamic' else None, | |
| known_robot_poses=poses,known_robot_playback=played, | |
| room_dimensions_m=[round(float(v),1) for v in group['room']['room_size_m']], | |
| known_room=dict(room_dimensions_m=[round(v,1) for v in group['room']['room_size_m']], | |
| measured_midfrequency_rt60_s=round(rooms[group['room_id']]['acoustic_check']['room_midfrequency_rt60_median_s'],3), | |
| materials=[{k:m[k] for k in ['name','absorption','scattering','transmission','labels']} | |
| for m in json.loads(rooms[group['room_id']]['files']['materials.json'])['materials']], | |
| surfaces=[dict(name=s['name'],center_m=[round(v,1) for v in s['location']], | |
| size_m=[round(v,1) for v in s['size']],material_label=s['class_']) for s in group['room']['surfaces']]), | |
| prompt_template_version=VERSION+'.1') | |
| g = dict(sample_id=sid,scene_id=episode['scene_id'],episode_id=eid,scene_group_id=group['group_id'], | |
| episode_group_id=group['group_id'],query_group_id=query_group,target_group_id=sample['target_group_id'], | |
| task_id=task,setting=setting,mode=mode,target_source_id=target,keyword_case=case, | |
| branch=episode['branch'],difficulty=episode['difficulty'],room_id=group['room_id'], | |
| area_bin=group['room']['area_bin'],rt_bin=group['room']['rt_bin'], | |
| num_humans=len(episode['humans']),num_robots=len(episode['robots']), | |
| noise_type=episode['noise']['kind'] if episode['noise']['enabled'] else 'clean', | |
| noise_nominal_snr_db=episode['noise'].get('nominal_snr_db') if episode['noise']['enabled'] else None, | |
| layout_template=group['room']['template'], | |
| target_human_motion='moving' if any(np.any(h['displacement_m']) for h in episode['humans'] if target in ['all_humans','all_speech',h['entity_id']]) else 'stationary', | |
| observed_receiver_motion='moving' if any(np.any(r['displacement_m']) for r in episode['robots'] if r['entity_id'] in observed) else 'stationary', | |
| expected_times_s=[s/SR for s in grid(episode)] if mode=='dynamic' else [],output=answer) | |
| if task == 'DOA': | |
| g['source_roles'] = ['human']*len(episode['humans']) + ['robot']*sum(s['entity_id']!=reference for s in episode['playback_sources']) | |
| data['inputs'].append(sample) | |
| data['prompts'].append(dict(sample_id=sid,prompt_template_version=sample['prompt_template_version'],rendered_prompt=render(sample))) | |
| data['gold'].append(g) | |
| if task=='KW_ASR' and case=='unique_human': | |
| human=next(h for h in episode['humans'] if h['entity_id']==target) | |
| for choice in keyword_alternatives(episode,human): | |
| data['keyword_variants'].append(dict(sample_id=sid,word_count=choice['word_count'], | |
| query=dict(wake_phrase=choice['wake_phrase']))) | |
| data['pairs'].append(dict(query_group_id=query_group,sample_id=sid,episode_id=eid, | |
| setting=setting,receiver_ids=observed,target_group_id=sample['target_group_id'])) | |
| data['physical_pairs'].extend(group['static_dynamic_pairs']) | |
| data['ablation_groups'].append(group_manifest(group,mode)) | |
| if not pilot and (len(data['episodes'])!=2000 or len(data['scenes'])!=100): | |
| raise ValueError('Export must include 100 halls and exactly 2000 physical episodes') | |
| for name in ['scenes','episodes','recordings','views','inputs','prompts','pairs','physical_pairs','keyword_variants']: | |
| jsonl(destination/'public/test'/(name+'.jsonl'),data[name]) | |
| for name,key in [('gold','gold'),('episodes','private_episodes'),('query_exclusions','excluded')]: | |
| jsonl(destination/'private/test'/(name+'.jsonl'),data[key]) | |
| jsonl(destination/'private/ablation_groups.jsonl',data['ablation_groups']) | |
| write(destination/'public/evaluation_protocol.json',dict(schema_version=VERSION,mode=mode, | |
| label_step_s=.5 if mode=='dynamic' else None,source_rir_step_s=.2,receiver_rir_step_s=.2, | |
| thresholds=dict(doa_deg=20.,distance_m=.5,world_m=.5), | |
| targets='Dynamic spatial tasks: humans only, robot playback is interference; static DOA also includes other robot playback.', | |
| inference='Each prediction sees one sample only; do not access private truth or sibling task queries/transcripts.', | |
| scoring='Fixed whole-clip track identity. Silence not scored spatially; activity/coverage reported. Missing predictions remain failures.')) | |
| write(destination/'public/ablation_recipes.json',ablation_recipes()) | |
| with (destination/'public/test/index.jsonl').open('w') as output: | |
| for sample in data['inputs']: | |
| output.write(json.dumps({k:sample[k] for k in ['sample_id','episode_id','scene_id','task_id','setting','mode']},separators=(',',':'))+'\n') | |
| summary = dict(schema_version=VERSION,mode=mode,halls=len(data['scenes']),physical_episodes=len(data['episodes']), | |
| recordings=len(data['recordings']),edge_views=sum(v['setting']=='edge' for v in data['views']), | |
| cloud_views=sum(v['setting']=='cloud' for v in data['views']),task_requests=len(data['inputs']), | |
| tasks=dict(Counter(r['setting']+'/'+r['task_id'] for r in data['inputs'])), | |
| label_step_s=.5 if mode=='dynamic' else None,source_rir_step_s=.2,receiver_rir_step_s=.2, | |
| ambiguous_queries_excluded=len(data['excluded']),binaural_recordings=0,pilot=pilot) | |
| write(destination/'summary.json',summary) | |
| print('EXPORT COMPLETE',mode,summary['physical_episodes'],'episodes',summary['task_requests'],'questions',flush=True) | |
| return summary | |
| if __name__ == '__main__': | |
| parser=argparse.ArgumentParser() | |
| parser.add_argument('--root',type=Path,required=True) | |
| parser.add_argument('--mode',choices=['static','dynamic'],required=True) | |
| parser.add_argument('--pilot',action='store_true') | |
| parser.add_argument('--indices',type=int,nargs='*') | |
| a=parser.parse_args() | |
| export(a.root,a.mode,a.pilot,a.indices) | |