Heiheihaha17's picture
Add files using upload-large-folder tool
809dbd2 verified
Raw History Blame Contribute Delete
20 kB
"""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)