"""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))