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