Heiheihaha17's picture
Add files using upload-large-folder tool
347d9a3 verified
Raw History Blame Contribute Delete
11.9 kB
"""Canonical model-only inputs, separate gold and matched receiver task groups."""
from __future__ import annotations
import argparse,copy,secrets
from collections import Counter
from pathlib import Path
import numpy as np
from .common import *
from .prompts import render,robot_poses,playback_log
def motion_state(entities):
if not entities:return 'none'
moving=[bool(np.any(entity['displacement_m'])) for entity in entities]
return 'moving' if all(moving) else 'static' if not any(moving) else 'mixed'
def frames(scene,human,receiver=None,kind='xyz_m'):
out=[]
for sample in grid(scene):
t=sample/SR;on=active(human,sample);f=dict(time_s=t,active=on)
if on:f[kind]=position(human,t).tolist() if kind=='xyz_m' else geometry(human,receiver,t)[kind]
out.append(f)
return out
def private_scene(scene,group):
result=copy.deepcopy(scene);times=[s/SR for s in grid(scene)]
for e in result['humans']+result['robots']:
e['is_moving']=bool(np.any(e['displacement_m']));e['positions_world_m']=[[t]+position(e,t).tolist() for t in times]
e['velocities_world_mps']=[[t]+velocity(e,t).tolist() for t in times]
e['speeds_mps']=[float(np.linalg.norm(velocity(e,t))) for t in times]
length=float(np.linalg.norm(e['displacement_m']));e['motion_direction_world']=(np.asarray(e['displacement_m'])/length).tolist() if length else None
e['relative_to_robots']={}
for robot in scene['robots']:
if robot['entity_id']==e['entity_id']:
e['relative_to_robots'][robot['entity_id']]=dict(same_entity=True,distance_m=0.)
else:e['relative_to_robots'][robot['entity_id']]=[dict(time_s=t,
displacement_world_m=(position(e,t)-position(robot,t)).tolist(),**geometry(e,robot,t)) for t in times]
if e['entity_type']=='human':
spans=sorted(pair for event in e['events'] for pair in event['activity_samples']);on=e['motion_start_s'];off=on+e['motion_duration_s']
voiced=sum(max(0.,min(b/SR,off)-max(a/SR,on)) for a,b in spans)
gaps=[(a[1]/SR,b[0]/SR) for a,b in zip(spans,spans[1:]) if b[0]>a[1]]
e['continuity_audit']=dict(maximum_internal_silence_s=max_internal_gap(e['events']),
motion_interval_s=[on,off],voiced_fraction_during_motion=voiced/(off-on),
maximum_displacement_during_internal_silence_m=max((float(np.linalg.norm(position(e,b)-position(e,a))) for a,b in gaps),default=0.))
result['room_stratum']=dict(area_bin=group['room']['area_bin'],rt_bin=group['room']['rt_bin'],area_m2=group['room']['area_m2'])
return result
def export(root,pilot=False):
root=root.resolve();groups=list(rows(root/'private/recipes.jsonl'));config=read(root/'config.json')
if pilot:groups=[g for g in groups if (root/'reports/groups'/(g['group_id']+'.json')).exists()]
if not groups:raise ValueError('No completed motion groups to export')
# A small candidate target vocabulary must not be recoverable by hashing
# public scene/query values. Freeze a private ID salt, separate from physics.
all_groups=list(rows(root/'private/recipes.jsonl'));nonces={}
for group in all_groups:
group.setdefault('evaluation_id_nonce',secrets.token_hex(16));nonces[group['group_id']]=group['evaluation_id_nonce']
jsonl(root/'private/recipes.jsonl',all_groups)
for group in groups:group['evaluation_id_nonce']=nonces[group['group_id']]
inputs=[];prompts=[];gold=[];public_scenes=[];private_scenes=[];records=[];views=[];pairs=[];motion_groups=[]
for group in groups:
nonce=group['evaluation_id_nonce']
report=read(root/'reports/groups'/(group['group_id']+'.json'))
if not report['passed']:raise ValueError('Cannot export an unverified render')
byscene={sid:[r for r in report['recordings'] if r['scene_id']==sid] for sid in report['scene_ids']}
motion_groups.append(dict(scene_group_id=group['group_id'],parent_static_scene_id=group['parent_static_scene_id'],room_id=group['room_id'],
scenes=[dict(scene_id=s['scene_id'],branch=s['branch'],difficulty=s['difficulty']) for s in group['scenes']]))
for scene in group['scenes']:
sid=scene['scene_id'];rids=[r['entity_id'] for r in scene['robots']];recs={r['receiver_robot_id']:r for r in byscene[sid]};records.extend(byscene[sid])
pub=dict(schema_version=VERSION,scene_id=sid,scene_group_id=group['group_id'],parent_static_scene_id=group['parent_static_scene_id'],
split='test',room_id=group['room_id'],branch=scene['branch'],difficulty=scene['difficulty'],duration_samples=scene['duration_samples'],
sample_rate_hz=SR,evaluation_step_samples=STEP,scene_robot_ids=rids,robot_pose_trajectories=robot_poses(scene),
robot_speech_metadata=playback_log(scene),room_asset_directory='public/assets/rooms/'+group['room_id']+'/assets/room',
strict_sync=True,own_playback_policy='ideal_own_only',coordinate_convention=scene['coordinate_convention'])
public_scenes.append(pub);private_scenes.append(private_scene(scene,group))
for observed in [[rid] for rid in rids]+[rids]:
views.append(dict(view_id=uid(sid,'view',observed),scene_id=sid,scene_group_id=group['group_id'],setting='cloud' if len(observed)>1 else 'edge',
receiver_ids=observed,recording_ids=[recs[r]['recording_id'] for r in observed]))
queries=[]
# Same whole-human DOA question, instantiated for every receiver.
doa_group=uid(sid,'query','DOA_TRAJECTORY','all_humans',nonce)
for robot in scene['robots']:
rid=robot['entity_id'];queries.append(('DOA_TRAJECTORY',[rid],rid,{},
dict(tracks=[dict(track_id=h['entity_id'],frames=frames(scene,h,robot,'doa_deg')) for h in scene['humans']]),'all_humans',None,doa_group))
for human in scene['humans']:
hid=human['entity_id'];query_group=uid(sid,'query','RANGE_TRAJECTORY',hid,nonce)
for robot in scene['robots']:
rid=robot['entity_id'];cue=next(q for q in scene['geometry_audit']['range_queries'] if q['source_id']==hid and q['receiver_id']==rid)
cue={k:v for k,v in cue.items() if k not in ['source_id','receiver_id']}
queries.append(('RANGE_TRAJECTORY',[rid],rid,cue,dict(frames=frames(scene,human,robot,'distance_m')),hid,None,query_group))
queries.append(('TEXT_TRAJECTORY',rids,None,dict(transcript=human['events'][0]['text']),dict(frames=frames(scene,human)),hid,None,
uid(sid,'query','TEXT_TRAJECTORY',hid,nonce)))
for target,phrase in scene['keywords'].items():
case='unique_human' if target.startswith('H') else target;human=next((h for h in scene['humans'] if h['entity_id']==target),None)
text=' '.join(e['text'] for e in sorted(human['events'],key=lambda e:e['start_sample'])) if human else ''
query_group=uid(sid,'query','KW_ASR',target,phrase,nonce)
for observed in [[rid] for rid in rids]+[rids]:queries.append(('KW_ASR',observed,None,dict(wake_phrase=phrase),text,target,case,query_group))
collected={}
for task,observed,reference,query,answer,target,case,query_group in queries:
setting='cloud' if len(observed)>1 else 'edge';view_id=uid(sid,'view',observed);sample_id=uid(sid,view_id,task,query_group)
binding=[dict(slot=i,robot_id=rid,recording_id=recs[rid]['recording_id'],path=recs[rid]['path'],sha256=recs[rid]['sha256']) for i,rid in enumerate(observed)]
prompt=render(scene,task,query,observed,reference)
row=dict(schema_version=VERSION,sample_id=sample_id,scene_id=sid,scene_group_id=group['group_id'],view_id=view_id,query_group_id=query_group,
target_group_id=uid(sid,'target',target,nonce),task_id=task,setting=setting,reference_robot_id=reference,
receiver_ids=observed,recording_ids=[recs[r]['recording_id'] for r in observed],audio_bindings=binding,
time_window_samples=[0,scene['duration_samples']],sample_rate_hz=SR,evaluation_step_samples=STEP,
query=query,known_robot_poses=robot_poses(scene),known_robot_playback=playback_log(scene),
prompt_template_version=VERSION+'.1',output_schema='transcription_string' if task=='KW_ASR' else 'human_tracks_json' if task=='DOA_TRAJECTORY' else 'trajectory_json')
g=dict(sample_id=sample_id,scene_id=sid,scene_group_id=group['group_id'],query_group_id=query_group,target_group_id=row['target_group_id'],
task_id=task,setting=setting,branch=scene['branch'],difficulty=scene['difficulty'],target_source_id=target,
room_id=group['room_id'],area_bin=group['room']['area_bin'],rt_bin=group['room']['rt_bin'],
num_humans=len(scene['humans']),num_robots=len(rids),expected_times_s=[s/SR for s in grid(scene)],keyword_case=case,output=answer)
target_humans=scene['humans'] if task=='DOA_TRAJECTORY' else [h for h in scene['humans'] if h['entity_id']==target]
g['target_human_motion']=motion_state(target_humans)
g['observed_receiver_motion']=motion_state([r for r in scene['robots'] if r['entity_id'] in observed])
if case=='robot_only':
matching=[r['entity_id'] for r in scene['playback_sources'] if any(tokens(e['text'])[:len(tokens(query['wake_phrase']))]==tokens(query['wake_phrase']) for e in r['events'])]
g['keyword_observation_case']='robot_only_audible' if any(source!=receiver for source in matching for receiver in observed) else 'robot_only_removed'
inputs.append(row);prompts.append(dict(sample_id=sample_id,prompt_template_version=row['prompt_template_version'],rendered_prompt=prompt));gold.append(g)
collected.setdefault(query_group,dict(query_group_id=query_group,scene_id=sid,task_id=task,target_group_id=row['target_group_id'],samples=[]))['samples'].append(dict(sample_id=sample_id,view_id=view_id,setting=setting,receiver_ids=observed))
pairs.extend(collected.values())
if not pilot and len(public_scenes)!=2000:raise ValueError('Full export requires exactly 2,000 completed physical scenes')
shuffled=sorted(zip(inputs,prompts,gold),key=lambda t:t[0]['sample_id'])
inputs=[a for a,b,c in shuffled];prompts=[b for a,b,c in shuffled];gold=[c for a,b,c in shuffled]
for name,data in [('scenes',public_scenes),('recordings',records),('views',views),('pairs',pairs),('inputs',inputs),('prompts',prompts),('motion_groups',motion_groups)]:jsonl(root/'public/test'/(name+'.jsonl'),data)
jsonl(root/'private/test/scenes.jsonl',private_scenes);jsonl(root/'private/test/gold.jsonl',gold)
report=dict(schema_version=VERSION,physical_scenes=len(public_scenes),paired_motion_groups=len(groups),rooms=len({s['room_id'] for s in public_scenes}),
recordings=len(records),binaural_previews=0,views=len(views),task_requests=len(inputs),query_groups=len(pairs),
tasks=dict(Counter((r['setting']+'/'+r['task_id']) for r in inputs)),branches=dict(Counter(s['branch'] for s in public_scenes)),
output_step_s=.2,model_inference_performed=False,human_listening_audit_completed=False,pilot=pilot)
write(root/'summary.json',report)
from .loader import build_index
assert build_index(root)==len(inputs)
print('EXPORTED',report,flush=True)
if __name__=='__main__':
p=argparse.ArgumentParser();p.add_argument('--root',type=Path,required=True);p.add_argument('--pilot',action='store_true');a=p.parse_args();export(a.root,a.pilot)