Datasets:
Download code/dynamic_dataset/render.py from Heiheihaha17/MESH-Benchmark: direct link, hf CLI and curl.
- Browser
- Download file 12.7 kB
-
https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/dynamic_dataset/render.py
- Command line
-
hf download hf://datasets/Heiheihaha17/MESH-Benchmark/code/dynamic_dataset/render.py
-
curl -L -o render.py https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/dynamic_dataset/render.py
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) | |