Datasets:
Download code/dynamic_dataset/export.py from Heiheihaha17/MESH-Benchmark: direct link, hf CLI and curl.
- Browser
- Download file 11.9 kB
-
https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/dynamic_dataset/export.py
- Command line
-
hf download hf://datasets/Heiheihaha17/MESH-Benchmark/code/dynamic_dataset/export.py
-
curl -L -o export.py https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/dynamic_dataset/export.py
11.9 kB
| """Canonical model-only inputs, separate gold and matched receiver task groups.""" | |
| from __future__ import annotations | |
| import argparse,copy,secrets | |
| from collections import Counter | |
| from pathlib import Path | |
| import numpy as np | |
| from .common import * | |
| from .prompts import render,robot_poses,playback_log | |
| def motion_state(entities): | |
| if not entities:return 'none' | |
| moving=[bool(np.any(entity['displacement_m'])) for entity in entities] | |
| return 'moving' if all(moving) else 'static' if not any(moving) else 'mixed' | |
| def frames(scene,human,receiver=None,kind='xyz_m'): | |
| out=[] | |
| for sample in grid(scene): | |
| t=sample/SR;on=active(human,sample);f=dict(time_s=t,active=on) | |
| if on:f[kind]=position(human,t).tolist() if kind=='xyz_m' else geometry(human,receiver,t)[kind] | |
| out.append(f) | |
| return out | |
| def private_scene(scene,group): | |
| result=copy.deepcopy(scene);times=[s/SR for s in grid(scene)] | |
| for e in result['humans']+result['robots']: | |
| e['is_moving']=bool(np.any(e['displacement_m']));e['positions_world_m']=[[t]+position(e,t).tolist() for t in times] | |
| e['velocities_world_mps']=[[t]+velocity(e,t).tolist() for t in times] | |
| e['speeds_mps']=[float(np.linalg.norm(velocity(e,t))) for t in times] | |
| length=float(np.linalg.norm(e['displacement_m']));e['motion_direction_world']=(np.asarray(e['displacement_m'])/length).tolist() if length else None | |
| e['relative_to_robots']={} | |
| for robot in scene['robots']: | |
| if robot['entity_id']==e['entity_id']: | |
| e['relative_to_robots'][robot['entity_id']]=dict(same_entity=True,distance_m=0.) | |
| else:e['relative_to_robots'][robot['entity_id']]=[dict(time_s=t, | |
| displacement_world_m=(position(e,t)-position(robot,t)).tolist(),**geometry(e,robot,t)) for t in times] | |
| if e['entity_type']=='human': | |
| spans=sorted(pair for event in e['events'] for pair in event['activity_samples']);on=e['motion_start_s'];off=on+e['motion_duration_s'] | |
| voiced=sum(max(0.,min(b/SR,off)-max(a/SR,on)) for a,b in spans) | |
| gaps=[(a[1]/SR,b[0]/SR) for a,b in zip(spans,spans[1:]) if b[0]>a[1]] | |
| e['continuity_audit']=dict(maximum_internal_silence_s=max_internal_gap(e['events']), | |
| motion_interval_s=[on,off],voiced_fraction_during_motion=voiced/(off-on), | |
| maximum_displacement_during_internal_silence_m=max((float(np.linalg.norm(position(e,b)-position(e,a))) for a,b in gaps),default=0.)) | |
| result['room_stratum']=dict(area_bin=group['room']['area_bin'],rt_bin=group['room']['rt_bin'],area_m2=group['room']['area_m2']) | |
| return result | |
| def export(root,pilot=False): | |
| root=root.resolve();groups=list(rows(root/'private/recipes.jsonl'));config=read(root/'config.json') | |
| if pilot:groups=[g for g in groups if (root/'reports/groups'/(g['group_id']+'.json')).exists()] | |
| if not groups:raise ValueError('No completed motion groups to export') | |
| # A small candidate target vocabulary must not be recoverable by hashing | |
| # public scene/query values. Freeze a private ID salt, separate from physics. | |
| all_groups=list(rows(root/'private/recipes.jsonl'));nonces={} | |
| for group in all_groups: | |
| group.setdefault('evaluation_id_nonce',secrets.token_hex(16));nonces[group['group_id']]=group['evaluation_id_nonce'] | |
| jsonl(root/'private/recipes.jsonl',all_groups) | |
| for group in groups:group['evaluation_id_nonce']=nonces[group['group_id']] | |
| inputs=[];prompts=[];gold=[];public_scenes=[];private_scenes=[];records=[];views=[];pairs=[];motion_groups=[] | |
| for group in groups: | |
| nonce=group['evaluation_id_nonce'] | |
| report=read(root/'reports/groups'/(group['group_id']+'.json')) | |
| if not report['passed']:raise ValueError('Cannot export an unverified render') | |
| byscene={sid:[r for r in report['recordings'] if r['scene_id']==sid] for sid in report['scene_ids']} | |
| motion_groups.append(dict(scene_group_id=group['group_id'],parent_static_scene_id=group['parent_static_scene_id'],room_id=group['room_id'], | |
| scenes=[dict(scene_id=s['scene_id'],branch=s['branch'],difficulty=s['difficulty']) for s in group['scenes']])) | |
| for scene in group['scenes']: | |
| sid=scene['scene_id'];rids=[r['entity_id'] for r in scene['robots']];recs={r['receiver_robot_id']:r for r in byscene[sid]};records.extend(byscene[sid]) | |
| pub=dict(schema_version=VERSION,scene_id=sid,scene_group_id=group['group_id'],parent_static_scene_id=group['parent_static_scene_id'], | |
| split='test',room_id=group['room_id'],branch=scene['branch'],difficulty=scene['difficulty'],duration_samples=scene['duration_samples'], | |
| sample_rate_hz=SR,evaluation_step_samples=STEP,scene_robot_ids=rids,robot_pose_trajectories=robot_poses(scene), | |
| robot_speech_metadata=playback_log(scene),room_asset_directory='public/assets/rooms/'+group['room_id']+'/assets/room', | |
| strict_sync=True,own_playback_policy='ideal_own_only',coordinate_convention=scene['coordinate_convention']) | |
| public_scenes.append(pub);private_scenes.append(private_scene(scene,group)) | |
| for observed in [[rid] for rid in rids]+[rids]: | |
| views.append(dict(view_id=uid(sid,'view',observed),scene_id=sid,scene_group_id=group['group_id'],setting='cloud' if len(observed)>1 else 'edge', | |
| receiver_ids=observed,recording_ids=[recs[r]['recording_id'] for r in observed])) | |
| queries=[] | |
| # Same whole-human DOA question, instantiated for every receiver. | |
| doa_group=uid(sid,'query','DOA_TRAJECTORY','all_humans',nonce) | |
| for robot in scene['robots']: | |
| rid=robot['entity_id'];queries.append(('DOA_TRAJECTORY',[rid],rid,{}, | |
| dict(tracks=[dict(track_id=h['entity_id'],frames=frames(scene,h,robot,'doa_deg')) for h in scene['humans']]),'all_humans',None,doa_group)) | |
| for human in scene['humans']: | |
| hid=human['entity_id'];query_group=uid(sid,'query','RANGE_TRAJECTORY',hid,nonce) | |
| for robot in scene['robots']: | |
| rid=robot['entity_id'];cue=next(q for q in scene['geometry_audit']['range_queries'] if q['source_id']==hid and q['receiver_id']==rid) | |
| cue={k:v for k,v in cue.items() if k not in ['source_id','receiver_id']} | |
| queries.append(('RANGE_TRAJECTORY',[rid],rid,cue,dict(frames=frames(scene,human,robot,'distance_m')),hid,None,query_group)) | |
| queries.append(('TEXT_TRAJECTORY',rids,None,dict(transcript=human['events'][0]['text']),dict(frames=frames(scene,human)),hid,None, | |
| uid(sid,'query','TEXT_TRAJECTORY',hid,nonce))) | |
| for target,phrase in scene['keywords'].items(): | |
| case='unique_human' if target.startswith('H') else target;human=next((h for h in scene['humans'] if h['entity_id']==target),None) | |
| text=' '.join(e['text'] for e in sorted(human['events'],key=lambda e:e['start_sample'])) if human else '' | |
| query_group=uid(sid,'query','KW_ASR',target,phrase,nonce) | |
| for observed in [[rid] for rid in rids]+[rids]:queries.append(('KW_ASR',observed,None,dict(wake_phrase=phrase),text,target,case,query_group)) | |
| collected={} | |
| for task,observed,reference,query,answer,target,case,query_group in queries: | |
| setting='cloud' if len(observed)>1 else 'edge';view_id=uid(sid,'view',observed);sample_id=uid(sid,view_id,task,query_group) | |
| binding=[dict(slot=i,robot_id=rid,recording_id=recs[rid]['recording_id'],path=recs[rid]['path'],sha256=recs[rid]['sha256']) for i,rid in enumerate(observed)] | |
| prompt=render(scene,task,query,observed,reference) | |
| row=dict(schema_version=VERSION,sample_id=sample_id,scene_id=sid,scene_group_id=group['group_id'],view_id=view_id,query_group_id=query_group, | |
| target_group_id=uid(sid,'target',target,nonce),task_id=task,setting=setting,reference_robot_id=reference, | |
| receiver_ids=observed,recording_ids=[recs[r]['recording_id'] for r in observed],audio_bindings=binding, | |
| time_window_samples=[0,scene['duration_samples']],sample_rate_hz=SR,evaluation_step_samples=STEP, | |
| query=query,known_robot_poses=robot_poses(scene),known_robot_playback=playback_log(scene), | |
| prompt_template_version=VERSION+'.1',output_schema='transcription_string' if task=='KW_ASR' else 'human_tracks_json' if task=='DOA_TRAJECTORY' else 'trajectory_json') | |
| g=dict(sample_id=sample_id,scene_id=sid,scene_group_id=group['group_id'],query_group_id=query_group,target_group_id=row['target_group_id'], | |
| task_id=task,setting=setting,branch=scene['branch'],difficulty=scene['difficulty'],target_source_id=target, | |
| room_id=group['room_id'],area_bin=group['room']['area_bin'],rt_bin=group['room']['rt_bin'], | |
| num_humans=len(scene['humans']),num_robots=len(rids),expected_times_s=[s/SR for s in grid(scene)],keyword_case=case,output=answer) | |
| target_humans=scene['humans'] if task=='DOA_TRAJECTORY' else [h for h in scene['humans'] if h['entity_id']==target] | |
| g['target_human_motion']=motion_state(target_humans) | |
| g['observed_receiver_motion']=motion_state([r for r in scene['robots'] if r['entity_id'] in observed]) | |
| if case=='robot_only': | |
| matching=[r['entity_id'] for r in scene['playback_sources'] if any(tokens(e['text'])[:len(tokens(query['wake_phrase']))]==tokens(query['wake_phrase']) for e in r['events'])] | |
| g['keyword_observation_case']='robot_only_audible' if any(source!=receiver for source in matching for receiver in observed) else 'robot_only_removed' | |
| inputs.append(row);prompts.append(dict(sample_id=sample_id,prompt_template_version=row['prompt_template_version'],rendered_prompt=prompt));gold.append(g) | |
| collected.setdefault(query_group,dict(query_group_id=query_group,scene_id=sid,task_id=task,target_group_id=row['target_group_id'],samples=[]))['samples'].append(dict(sample_id=sample_id,view_id=view_id,setting=setting,receiver_ids=observed)) | |
| pairs.extend(collected.values()) | |
| if not pilot and len(public_scenes)!=2000:raise ValueError('Full export requires exactly 2,000 completed physical scenes') | |
| shuffled=sorted(zip(inputs,prompts,gold),key=lambda t:t[0]['sample_id']) | |
| inputs=[a for a,b,c in shuffled];prompts=[b for a,b,c in shuffled];gold=[c for a,b,c in shuffled] | |
| for name,data in [('scenes',public_scenes),('recordings',records),('views',views),('pairs',pairs),('inputs',inputs),('prompts',prompts),('motion_groups',motion_groups)]:jsonl(root/'public/test'/(name+'.jsonl'),data) | |
| jsonl(root/'private/test/scenes.jsonl',private_scenes);jsonl(root/'private/test/gold.jsonl',gold) | |
| report=dict(schema_version=VERSION,physical_scenes=len(public_scenes),paired_motion_groups=len(groups),rooms=len({s['room_id'] for s in public_scenes}), | |
| recordings=len(records),binaural_previews=0,views=len(views),task_requests=len(inputs),query_groups=len(pairs), | |
| tasks=dict(Counter((r['setting']+'/'+r['task_id']) for r in inputs)),branches=dict(Counter(s['branch'] for s in public_scenes)), | |
| output_step_s=.2,model_inference_performed=False,human_listening_audit_completed=False,pilot=pilot) | |
| write(root/'summary.json',report) | |
| from .loader import build_index | |
| assert build_index(root)==len(inputs) | |
| print('EXPORTED',report,flush=True) | |
| if __name__=='__main__': | |
| p=argparse.ArgumentParser();p.add_argument('--root',type=Path,required=True);p.add_argument('--pilot',action='store_true');a=p.parse_args();export(a.root,a.pilot) | |