Heiheihaha17's picture
Use relative distance accuracy and trajectory-macro scoring (score.4)
87e9f4d verified
Raw History Blame Contribute Delete
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))