Heiheihaha17's picture
Add files using upload-large-folder tool
347d9a3 verified
Raw History Blame Contribute Delete
12.7 kB
"""Allocated-CPU group renderer: true two-time RIRs and four-channel FOA."""
from __future__ import annotations
import argparse,gzip,json,os,shutil,tempfile,time,math,subprocess,sys
from pathlib import Path
import numpy as np
import soundfile as sf
from dynamic_demo.render import Renderer,make_dry,two_time_convolution
from .common import *
from .geometry import audit
from .runtime import ensure_compute
def sampling_nodes(entity,step):
"""Common scene-zero clock; every moving source/receiver uses 0, .2, .4, ..."""
if not np.any(entity['displacement_m']):return [0.]
end=entity.get('motion_start_s',0.)+entity['motion_duration_s']
last=math.ceil((end-1e-9)/step)
return [round(i*step,9) for i in range(last+1)]
def render_group(root,group,temp_root=None,cache_base=None,keep_cache=False):
marker=root/'reports/groups'/(group['group_id']+'.json')
if marker.exists():
previous=read(marker)
if previous.get('passed') and all(sha(root/r['path'])==r['sha256'] for r in previous['files']):return previous
raise ValueError('Completed group has changed; restore it before resuming')
started=time.monotonic();cache_base=Path(cache_base) if cache_base else Path(tempfile.mkdtemp(prefix='dish-dynamic-'+group['group_id']+'-',dir=temp_root))
cache_base.mkdir(parents=True,exist_ok=True)
engine_root=cache_base/'engine';(engine_root/'assets').mkdir(parents=True,exist_ok=True)
room_link=engine_root/'assets/room';room_target=root/'public/assets/rooms'/group['room_id']/'assets/room'
if room_link.exists():
if not room_link.is_symlink() or room_link.resolve()!=room_target.resolve():raise ValueError('Recovery cache room differs')
else:room_link.symlink_to(room_target,target_is_directory=True)
engine=Renderer(engine_root,group,cache_base/'rirs',position_fn=position)
mixtures={};stems={};source_gains=[];geometries=[]
def tracked_kernel(source,receiver,te,tr):
write(cache_base/'progress.json',dict(time=time.time(),source_id=source['entity_id'],receiver_id=receiver['entity_id'],source_time_s=te,receiver_time_s=tr))
return engine.kernel(source,receiver,te,tr)
try:
for scene in group['scenes']:
checked=audit(scene,group['room'],full_visibility=True)
if checked is None:raise ValueError('Frozen dynamic geometry failed independent rerun')
geometries.append(dict(scene_id=scene['scene_id'],**checked))
dry,gains=make_dry(root,scene);source_gains.append(dict(scene_id=scene['scene_id'],gains=gains))
for receiver in scene['robots']:
rid=receiver['entity_id'];key=(scene['scene_id'],rid);wave=np.zeros((scene['duration_samples'],4),np.float64)
for source in scene['humans']+scene['playback_sources']:
sid=source['entity_id']
if sid==rid:continue
component=two_time_convolution(dry[sid],sampling_nodes(source,group['source_node_step_s']),sampling_nodes(receiver,group['receiver_node_step_s']),
lambda te,tr:tracked_kernel(source,receiver,te,tr),max_tail_s=group.get('convolution_horizon_s',group['renderer']['irTime']+.001))
wave+=component;stems[(scene['scene_id'],rid,sid)]=component
mixtures[key]=wave.astype(np.float32)
print('RENDERED SCENE',scene['scene_id'],scene['branch'],len(engine.records),'RIRs',flush=True)
peak=max(float(np.max(np.abs(w))) for w in mixtures.values());gain=.9/peak
if not np.isfinite(peak) or peak<=0:raise ValueError('Invalid mixture')
files=[];records=[];audio_checks=[]
for scene in group['scenes']:
for receiver in scene['robots']:
rid=receiver['entity_id'];key=(scene['scene_id'],rid);wave=(mixtures[key]*gain).astype(np.float32)
path=root/'public/audio/test'/scene['scene_id']/(rid+'_foa.wav');path.parent.mkdir(parents=True,exist_ok=True)
tmp=path.with_name(rid+'_foa.tmp.wav');sf.write(tmp,wave,SR,subtype='FLOAT');tmp.replace(path)
reconstructed=sum(stems[(scene['scene_id'],rid,s['entity_id'])].astype(np.float64) for s in scene['humans']+scene['playback_sources'] if s['entity_id']!=rid)*gain
deviation=float(np.max(np.abs(wave-reconstructed)))
if deviation>3e-7:raise ValueError('Source-stem reconstruction mismatch')
reread,rate=sf.read(path,dtype='float32');np.testing.assert_array_equal(reread,wave)
if rate!=SR:raise ValueError('FOA sample rate mismatch')
record=dict(recording_id=uid(scene['scene_id'],rid,'recording'),scene_id=scene['scene_id'],scene_group_id=group['group_id'],
receiver_robot_id=rid,path=str(path.relative_to(root)),sha256=sha(path),num_samples=len(wave),sample_rate_hz=SR,
num_channels=4,channels=['W','Y','Z','X'],ordering='ACN',normalization='SN3D',subtype='FLOAT',global_start_sample=0,
common_final_gain=gain)
records.append(record)
files.append(dict(path=str(path.relative_to(root)),sha256=sha(path),bytes=path.stat().st_size))
audio_checks.append(dict(scene_id=scene['scene_id'],receiver_id=rid,source_stem_reconstruction_max_error=deviation,
own_playback_excluded=True,contributing_source_ids=[s['entity_id'] for s in scene['humans']+scene['playback_sources'] if s['entity_id']!=rid],
waveform_peak=float(np.max(np.abs(wave))),all_finite=bool(np.isfinite(wave).all()),
tail_energy_fraction=float(np.sum(wave[-8000:].astype(float)**2)/np.sum(wave.astype(float)**2))))
rir_log=root/'private/rir_audits'/(group['group_id']+'.jsonl.gz');rir_log.parent.mkdir(parents=True,exist_ok=True)
with gzip.open(rir_log,'wt') as f:
for record in sorted(engine.records.values(),key=lambda x:x['rir_id']):f.write(json.dumps(record,separators=(',',':'))+'\n')
files.append(dict(path=str(rir_log.relative_to(root)),sha256=sha(rir_log),bytes=rir_log.stat().st_size))
result=dict(passed=True,group_id=group['group_id'],index=group['index'],scene_ids=[s['scene_id'] for s in group['scenes']],
room_id=group['room_id'],common_final_gain=gain,recordings=records,files=files,
source_gains=source_gains,geometry_checks=geometries,audio_checks=audio_checks,rir_audit_path=str(rir_log.relative_to(root)),
rir_count=len(engine.records),los_rir_count=sum(r['los'] for r in engine.records.values()),
maximum_los_direct_angle_error_deg=max(r['direct_angle_error_deg'] for r in engine.records.values() if r['los']),
maximum_los_delay_error_s=max(abs(r['direct_delay_s']-r['geometric_delay_s']) for r in engine.records.values() if r['los']),
maximum_native_tail_fraction=max(r['native_final_50ms_energy_fraction'] for r in engine.records.values()),
binaural_previews=False,wall_seconds=time.monotonic()-started,completed_at=now(),human_listening_audit_completed=False,model_inference_performed=False)
result['rir_sampling_policy']='source and receiver knots both on scene-zero 0.2s grid, through first knot at/after motion end; stationary entities use one knot'
result['convolution_horizon_s']=group.get('convolution_horizon_s',group['renderer']['irTime']+.001)
write(marker,result);print('GROUP COMPLETE',group['index'],group['group_id'],result['rir_count'],round(result['wall_seconds'],1),'s',flush=True)
return result
except Exception as error:
write(root/'reports/failures'/(group['group_id']+'.json'),dict(group_id=group['group_id'],index=group['index'],
room_id=group['room_id'],error_type=type(error).__name__,error=str(error),rir_count=len(engine.records),failed_at=now()))
raise
finally:
engine.close()
# Only this process's disposable, newly-created kernels; no source/release deletion.
if not keep_cache:shutil.rmtree(cache_base)
def supervise_group(root,group,temp_root=None,recovery=None,timeout=180.,attempts=3):
"""Fresh native process per group; restart a stalled RLR call with verified kernels."""
marker=root/'reports/groups'/(group['group_id']+'.json')
if marker.exists():return render_group(root,group)
cache=Path(tempfile.mkdtemp(prefix='dish-supervised-'+group['group_id']+'-',dir=temp_root))
if recovery and (Path(recovery)/group['group_id']).exists():
shutil.copytree(Path(recovery)/group['group_id'],cache/'rirs')
prefix=json.loads(os.environ.get('DISH_WORKER_PYTHON_COMMAND','null')) or [sys.executable]
command=prefix+['-m','dynamic_dataset.render','--root',str(root),'--single-index',str(group['index']),
'--expected-group-id',group['group_id'],'--cache-dir',str(cache)]
completed=False;history=[]
try:
for attempt in range(1,attempts+1):
start=time.time();process=subprocess.Popen(command)
try:
while process.poll() is None:
progress=cache/'progress.json';last=max(start,progress.stat().st_mtime if progress.exists() else start)
if time.time()-last>timeout:
process.kill();process.wait()
history.append(dict(attempt=attempt,inactive_s=time.time()-last,pending_kernel=read(progress) if progress.exists() else None))
print('RESTART STALLED NATIVE WORKER',group['index'],attempt,flush=True);break
time.sleep(1.)
finally:
if process.poll() is None:process.kill();process.wait()
if marker.exists():
result=render_group(root,group);completed=True
write(root/'reports/process_recovery'/(group['group_id']+'.json'),dict(passed=True,index=group['index'],attempts=attempt,restarts=history,
reused_pinned_native_cache=bool(recovery),same_geometry_renderer_and_speech=True,completed_at=now()))
return result
if not history or history[-1]['attempt']!=attempt:raise RuntimeError('Native worker failed; inspect reports/failures for index '+str(group['index']))
raise TimeoutError('Native kernel stalled after '+str(attempts)+' fresh-process attempts; index '+str(group['index']))
finally:
if completed:shutil.rmtree(cache)
else:print('PRESERVED RECOVERY CACHE',str(cache),flush=True)
def render(root,shard,shards,limit=0,processes=1,recovery=None,indices=None,timeout=180.):
ensure_compute();root=root.resolve();groups=list(rows(root/'private/recipes.jsonl'));selected=[g for g in groups if g['index']%shards==shard]
if indices is not None:selected=[g for g in selected if g['index'] in indices]
if limit:selected=selected[:limit]
failures=[]
from concurrent.futures import ThreadPoolExecutor,as_completed
with ThreadPoolExecutor(max_workers=processes) as executor:
futures={executor.submit(supervise_group,root,g,recovery=recovery,timeout=timeout):g for g in selected}
for future in as_completed(futures):
try:future.result()
except Exception as e:failures.append(dict(index=futures[future]['index'],error=str(e)))
write(root/'reports/workers'/f'{shard:02d}.json',dict(passed=not failures,shard=shard,shards=shards,groups=len(selected),failures=failures,completed_at=now()))
if failures:raise RuntimeError(str(len(failures))+' render groups failed; inspect reports/failures and resume this shard')
if __name__=='__main__':
p=argparse.ArgumentParser();p.add_argument('--root',type=Path,required=True);p.add_argument('--shard',type=int,default=0);p.add_argument('--shards',type=int,default=1);p.add_argument('--limit',type=int,default=0)
p.add_argument('--processes',type=int,default=1)
p.add_argument('--rir-recovery-cache',type=Path);p.add_argument('--indices',type=int,nargs='+');p.add_argument('--kernel-timeout-s',type=float,default=180.)
p.add_argument('--single-index',type=int);p.add_argument('--expected-group-id');p.add_argument('--cache-dir',type=Path)
a=p.parse_args()
if a.single_index is not None:
ensure_compute();group=next(g for g in rows(a.root/'private/recipes.jsonl') if g['index']==a.single_index)
if group['group_id']!=a.expected_group_id:raise ValueError('Frozen recipe changed during worker launch')
render_group(a.root.resolve(),group,cache_base=a.cache_dir,keep_cache=True)
else:render(a.root,a.shard,a.shards,a.limit,a.processes,a.rir_recovery_cache,a.indices,a.kernel_timeout_s)