Datasets:
Download code/exhibition_v3/export.py from Heiheihaha17/MESH-Benchmark: direct link, hf CLI and curl.
- Browser
- Download file 14.7 kB
-
https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/exhibition_v3/export.py
- Command line
-
hf download hf://datasets/Heiheihaha17/MESH-Benchmark/code/exhibition_v3/export.py
-
curl -L -o export.py https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/exhibition_v3/export.py
14.7 kB
| """Public prompts, private answers and correspondence for every actual receiver.""" | |
| from __future__ import annotations | |
| import argparse,collections,copy,json | |
| from pathlib import Path | |
| import numpy as np | |
| from exhibition_dataset.export import private_metadata | |
| from exhibition_dataset.prompts import ablation_recipes | |
| from exhibition_dataset.loader import build_index | |
| from .common import * | |
| from .tasks import TASK_VERSION,queries_for,evidence,cue_variants | |
| from .prompts import render | |
| from .scoring_protocol import update_ablation_recipes,update_evaluation_protocol | |
| def export(root,pilot=False,output_root=None): | |
| ensure_compute();groups=[read(p) for p in sorted((root/'private/plans').glob('*.json'))] | |
| output_root=Path(output_root) if output_root is not None else root | |
| rooms={r['room_id']:r for r in rows(root/'private/rooms.jsonl')} | |
| if pilot:groups=[g for g in groups if (root/'reports/bases'/f"{g['index']:04d}.json").exists()] | |
| elif len(groups)!=800:raise ValueError('Full export requires all 800 frozen bases') | |
| summaries={} | |
| for mode in ['static','dynamic']: | |
| dest=output_root/mode;data={k:[] for k in ['scenes','episodes','recordings','views','inputs','prompts','gold','metadata','pairs','physical_pairs','spatial_variants','excluded']} | |
| for group in groups: | |
| report=read(root/'reports/bases'/f"{group['index']:04d}.json") | |
| if not report['passed'] or not report['final_normalization_applied']:raise ValueError('Incomplete calibrated base') | |
| records={} | |
| for r in report['recordings']: | |
| if r['mode']!=mode:continue | |
| record=dict(r,path=str(Path(r['path']).relative_to(mode))) | |
| records[(r['episode_id'],r['receiver_robot_id'])]=record | |
| data['recordings'].append(record) | |
| room=rooms[group['room_id']] | |
| data['scenes'].append(dict(schema_version=VERSION,scene_id=group['base_scene_id'],base_scene_id=group['base_scene_id'], | |
| room_id=group['room_id'],base_seed=group['base_seed'],environment='exhibition_hall', | |
| room_dimensions_m=[round(v,1) for v in group['room']['room_size_m']], | |
| measured_midfrequency_rt60_s=room['acoustic_check']['room_midfrequency_rt60_median_s'])) | |
| for episode in group[mode+'_episodes']: | |
| eid=episode['episode_id'];rids=[r['entity_id'] for r in episode['robots']] | |
| poses=robot_poses(episode);played=playback_log(episode) | |
| public=dict(schema_version=VERSION,scene_id=group['base_scene_id'],base_scene_id=group['base_scene_id'], | |
| episode_id=eid,room_id=group['room_id'],mode=mode,variant_id=episode['variant_id'], | |
| duration_samples=episode['duration_samples'],sample_rate_hz=SR,label_step_s=.5 if mode=='dynamic' else None, | |
| scene_robot_ids=rids,known_robot_poses=poses,known_robot_playback=played, | |
| strict_sync=True,own_playback_policy='ideal_own_only') | |
| data['episodes'].append(public) | |
| metadata=private_metadata(episode,group) | |
| metadata.update(noise_calibration=report['noise_calibration'],common_final_gain=report['common_final_gain'], | |
| acoustic_measurements=[m for m in report['acoustic_measurements'] if m['episode_id']==eid]) | |
| data['metadata'].append(metadata) | |
| for setting,observed in [('edge',[r]) for r in rids]+[('cloud',rids)]: | |
| data['views'].append(dict(view_id=uid(eid,'view',setting,observed),episode_id=eid, | |
| base_scene_id=group['base_scene_id'],setting=setting,receiver_ids=observed, | |
| recording_ids=[records[(eid,r)]['recording_id'] for r in observed])) | |
| for task,setting,observed,reference,query,answer,target,case in queries_for(episode,group,data['excluded']): | |
| query_group=uid(TASK_VERSION,eid,'query',task,target,reference,query) | |
| view_id=uid(eid,'view',setting,observed);sid=uid(TASK_VERSION,eid,view_id,task,query_group) | |
| target_group=uid(eid,'target',target);base_target=uid(group['base_scene_id'],'target',target) | |
| content_pair=uid(eid,'text-localization',target,reference) if task in ['TEXT_DOA','TEXT_RANGE'] else None | |
| bindings=[dict(slot=i,robot_id=r,recording_id=records[(eid,r)]['recording_id'], | |
| path=records[(eid,r)]['path'],sha256=records[(eid,r)]['sha256']) for i,r in enumerate(observed)] | |
| known_room=dict(room_dimensions_m=[round(v,1) for v in group['room']['room_size_m']], | |
| measured_midfrequency_rt60_s=round(room['acoustic_check']['room_midfrequency_rt60_median_s'],3), | |
| 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']], | |
| materials=[{k:m[k] for k in ['name','absorption','scattering','transmission','labels']} for m in json.loads(room['files']['materials.json'])['materials']]) | |
| sample=dict(schema_version=VERSION,task_protocol_version=TASK_VERSION,sample_id=sid,scene_id=group['base_scene_id'],base_scene_id=group['base_scene_id'], | |
| episode_id=eid,episode_group_id=group['base_scene_id'],condition_id=episode['variant_id'], | |
| view_id=view_id,query_group_id=query_group,target_group_id=target_group,base_target_group_id=base_target, | |
| 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=known_room['room_dimensions_m'],known_room=known_room,prompt_template_version=TASK_VERSION, | |
| content_localization_pair_id=content_pair) | |
| gold=dict(sample_id=sid,scene_id=group['base_scene_id'],base_scene_id=group['base_scene_id'],episode_id=eid, | |
| episode_group_id=group['base_scene_id'],query_group_id=query_group,target_group_id=target_group, | |
| task_id=task,setting=setting,mode=mode,target_source_id=target,case=case, | |
| task_protocol_version=TASK_VERSION,reference_robot_id=reference,content_localization_pair_id=content_pair, | |
| 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(rids), | |
| noise_type=episode['noise']['kind'],noise_nominal_snr_db=episode['noise'].get('nominal_snr_db'), | |
| 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':gold['source_roles']=['human']*len(episode['humans'])+['robot']*sum(p['entity_id']!=reference for p in episode['playback_sources']) | |
| if task in ['DOA_RANGE_ASR','SPATIAL_ASR','WORLD_TRAJECTORY_ASR']: | |
| receiver=next((r for r in episode['robots'] if r['entity_id']==reference),None) | |
| gold.update(cue_type=query['cue_type'],cue_evidence=evidence(episode,receiver,query,target)) | |
| gold['evaluation_group']=gold['cue_evidence']['evaluation_group'] | |
| if not gold['cue_evidence']['passed']:raise ValueError('Exported spatial cue failed uniqueness') | |
| for variant in cue_variants(episode,receiver,query,target): | |
| data['spatial_variants'].append(dict(sample_id=sid,**variant)) | |
| data['inputs'].append(sample);data['gold'].append(gold) | |
| data['prompts'].append(dict(sample_id=sid,prompt_template_version=TASK_VERSION,rendered_prompt=render(sample))) | |
| data['pairs'].append(dict(sample_id=sid,episode_id=eid,base_scene_id=group['base_scene_id'],query_group_id=query_group, | |
| target_group_id=target_group,base_target_group_id=base_target,task_id=task,setting=setting,receiver_ids=observed, | |
| reference_robot_id=reference,content_localization_pair_id=content_pair)) | |
| data['physical_pairs'].extend(group['static_dynamic_pairs']) | |
| for name in ['scenes','episodes','recordings','views','inputs','prompts','pairs','physical_pairs']: | |
| jsonl(dest/'public/test'/f'{name}.jsonl',data[name]) | |
| jsonl(dest/'public/test/spatial_query_variants.jsonl',data['spatial_variants']) | |
| obsolete=dest/'public/test/keyword_variants.jsonl' | |
| if obsolete.exists():obsolete.unlink() | |
| for name,key in [('gold','gold'),('episodes','metadata'),('query_exclusions','excluded')]:jsonl(dest/'private/test'/f'{name}.jsonl',data[key]) | |
| build_index(dest) | |
| ablations=ablation_recipes();ablations.pop('keywords',None);ablations.update( | |
| acoustic_pairs='Only static vs each derivative holds content/noise/initial poses fixed. The two dynamic siblings are independent random draws, NOT a one-factor controlled pair.', | |
| distribution_comparisons='Noise/SNR/count comparisons across unrelated bases are observational strata, not strict causal ablations.', | |
| thresholds=dict(doa_deg=[5,10,20,30,45],distance_m=[.25,.5,1,1.5,2],world_m=[.25,.5,1,1.5,2]), | |
| spatial_cues='public/test/spatial_query_variants.jsonl contains only robustly unique ablations. Compare the intersection of eligible sample IDs. Use exhibition_v3.loader.Dataset.load(cue_variant=...).', | |
| spatial_asr_pairs='target_group_id links edge SPATIAL_ASR and one all-robot cloud WORLD_TRAJECTORY_ASR per human. Edge uses its own microphone coordinates; cloud uses a world trajectory. These share the target/transcript, not identical spatial cues, so their score difference is not a controlled receiver-count gain.', | |
| text_localization_pairs='content_localization_pair_id pairs static TEXT_DOA and TEXT_RANGE on the same transcript, target and receiver.') | |
| write(dest/'public/ablation_recipes.json',update_ablation_recipes(ablations)) | |
| write(dest/'public/evaluation_protocol.json',update_evaluation_protocol(dict(schema_version=VERSION,task_protocol_version=TASK_VERSION,label_step_s=.5 if mode=='dynamic' else None, | |
| source_rir_step_s=.2,receiver_rir_step_s=.2,default_thresholds=dict(doa_deg=20,distance_m=.5,world_m=.5), | |
| targets='Dynamic: human absolute tracks only. Static DOA additionally includes other robots playback.', | |
| scoring='Whole-clip identity assignment; spatial scores only on emitted-speech active frames. Missing predictions remain failures; activity and coverage reported.', | |
| inference='One question at a time. No private labels, source identities, sibling queries/transcripts or gold-accessing adapters.', | |
| independence='Cluster statistical resampling by room then base scene; all three variants and receiver views share content.', | |
| coordinate_binding='Edge directions and microphone distances belong to the supplied recording. Cloud trajectory ASR uses WORLD positions, with no reference robot.', | |
| world_trajectory_asr=dict(frame_step_s=.5,position_decimals=1,position_tolerance_candidates_m=[.5,.3], | |
| boundary_margin_m=.2,scope='Entire target transcript', | |
| frames='All scene-grid times, including silence; no speaking-activity labels are given.', | |
| stationary_targets='Retained and reported separately as stationary-target controls', | |
| cloud_queries='Exactly one per human per physical episode, receiving all robot recordings.'), | |
| spatial_asr=dict(scope='Entire target transcript, not just the interval between anchors',anchor_step_s=.5, | |
| minimum_anchor_separation_s=1.,minimum_azimuth_change_deg=20.,minimum_distance_change_m=.5, | |
| azimuth_tolerance_deg=10.,distance_tolerance_m=.5,angular_boundary_margin_deg=1.,distance_boundary_margin_m=.2, | |
| target_policy='Unique human; other robot speech and noise remain interference. No ambiguous or absent-target spatial ASR queries.', | |
| diagnostic_groups=['multi_human_spatial_selection','temporal_selection_control','single_human_control'])))) | |
| summary=dict(schema_version=VERSION,task_protocol_version=TASK_VERSION,mode=mode,rooms=len({g['room_id'] for g in groups}),base_scenes=len(groups), | |
| physical_episodes=len(data['episodes']),recordings=len(data['recordings']),views=len(data['views']), | |
| task_requests=len(data['inputs']),tasks=dict(collections.Counter(s['setting']+'/'+s['task_id'] for s in data['inputs'])), | |
| excluded_query_candidates=len(data['excluded']),exclusion_reasons=dict(collections.Counter(q['reason'] for q in data['excluded'])), | |
| spatial_asr_cue_types=dict(collections.Counter(g['cue_type'] for g in data['gold'] if g['task_id']=='SPATIAL_ASR' and g['setting']=='edge')), | |
| spatial_asr_diagnostic_groups=dict(collections.Counter(g['evaluation_group'] for g in data['gold'] if g['task_id']=='SPATIAL_ASR' and g['setting']=='edge')), | |
| world_asr_target_motion_counts=dict(collections.Counter(g['target_human_motion'] for g in data['gold'] if g['task_id']=='WORLD_TRAJECTORY_ASR')), | |
| pilot=pilot,binaural_recordings=0) | |
| write(dest/'summary.json',summary);summaries[mode]=summary | |
| return summaries | |
| if __name__=='__main__': | |
| p=argparse.ArgumentParser();p.add_argument('--root',type=Path,required=True);p.add_argument('--output-root',type=Path);p.add_argument('--pilot',action='store_true');a=p.parse_args();print(export(a.root,a.pilot,a.output_root)) | |