"""Joint normalization, independent full acceptance and frozen reproduction recipes.""" from __future__ import annotations import argparse from collections import Counter,defaultdict import copy import gzip import json import math from pathlib import Path import time import sys import importlib.metadata import subprocess import numpy as np import soundfile as sf from .common import * from .export import export,keyword_alternatives,region_members from .loader import build_index,Dataset from .plan import audit_geometry from .prompts import render from .score import evaluate def normalize_family(root,group): journal_path=root/'private/normalization'/(group['group_id']+'.json') reports={mode:read(root/mode/'reports/groups'/(group['group_id']+'.json')) for mode in ['static','dynamic']} gain=.9/max(r['raw_peak'] for r in reports.values()) journal=read(journal_path) if journal_path.exists() else dict(gain=gain,recordings={}) if journal['gain']!=gain: raise ValueError('Joint family normalization gain changed') for mode,report in reports.items(): for recording in report['recordings']: key=mode+'/'+recording['recording_id'] path=root/mode/recording['path'] current=sha(path) previous=journal['recordings'].get(key) if previous and current in [previous['normalized_sha256'],previous.get('previous_normalized_sha256')]: # Earlier pilot normalization used a timestamped PEAK header. # Canonicalizing an already-normalized file never scales again. wave,rate=sf.read(path,dtype='float32') temporary=path.with_suffix('.normalized.tmp.wav') write_float_wav(temporary,wave,rate) target_hash=sha(temporary) if target_hash!=current: previous['previous_normalized_sha256']=current previous['normalized_sha256']=target_hash write(journal_path,journal) temporary.replace(path) else: temporary.unlink() recording.update(sha256=target_hash,common_final_gain=gain) continue if previous and current!=previous['raw_sha256']: raise ValueError('Normalization encountered an unexpected audio checksum') if not previous and report.get('final_normalization_applied'): if current!=recording['sha256']: raise ValueError('Normalized recording changed') continue raw_hash=current wave,rate=sf.read(path,dtype='float32') wave=(wave*gain).astype(np.float32) if not np.isfinite(wave).all() or float(np.max(np.abs(wave)))>.900001: raise ValueError('Joint normalization overflow') temporary=path.with_suffix('.normalized.tmp.wav') write_float_wav(temporary,wave,rate) target_hash=sha(temporary) journal['recordings'][key]=dict(raw_sha256=raw_hash,normalized_sha256=target_hash) write(journal_path,journal) # recovery knows both hashes BEFORE replacement temporary.replace(path) recording.update(sha256=target_hash,common_final_gain=gain) if not report.get('acoustic_power_normalization_applied'): for measurement in report['acoustic_measurements']: for key in ['target_power','competing_speech_power','environmental_noise_power']: measurement['raw_'+key]=measurement[key] measurement[key]*=gain**2 measurement['power_stage']='published FOA after joint family normalization' report['acoustic_power_normalization_applied']=True report.update(final_normalization_applied=True,common_final_gain=gain) write(root/mode/'reports/groups'/(group['group_id']+'.json'),report) journal['complete']=True write(journal_path,journal) def scoring_selftest(destination): gold=list(rows(destination/'private/test/gold.jsonl')) oracle=destination/'reports/scorer_selftest/oracle.jsonl' jsonl(oracle,[dict(sample_id=g['sample_id'],output=g['output']) for g in gold]) result=evaluate(destination,oracle,destination/'reports/scorer_selftest/perfect') for key,values in result['metrics'].items(): if '/branch/' in key or '/robots/' in key or '/humans/' in key or '/rt_bin/' in key or '/case/' in key: continue if values['format_valid_fraction']!=1.: raise ValueError('Scorer rejects its own canonical answers: '+key) if 'corpus_wer' in values: if values['corpus_wer'] not in [0.,None] or values['negative_empty_accuracy'] not in [1.,None]: raise ValueError('ASR oracle score is not perfect') else: if values['coverage']!=1. or values['mean_error'] is None or values['mean_error']>1e-5: raise ValueError('Spatial oracle score is not perfect') missing=destination/'reports/scorer_selftest/missing.jsonl' jsonl(missing,[]) failures=evaluate(destination,missing,destination/'reports/scorer_selftest/missing') if failures['samples']!=len(gold) or failures['missing_predictions']!=len(gold): raise ValueError('Missing predictions escaped the denominator') write(destination/'reports/scorer_selftest/complete.json',dict(passed=True,oracle_predictions_are_not_model_inference=True, perfect_answer_samples=len(gold),all_missing_samples_counted=len(gold))) def audit(root,mode,pilot=False): destination=root/mode episodes=list(rows(destination/'private/test/episodes.jsonl')) public={e['episode_id']:e for e in rows(destination/'public/test/episodes.jsonl')} inputs=list(rows(destination/'public/test/inputs.jsonl')) prompts={r['sample_id']:r for r in rows(destination/'public/test/prompts.jsonl')} gold={r['sample_id']:r for r in rows(destination/'private/test/gold.jsonl')} recordings={r['recording_id']:r for r in rows(destination/'public/test/recordings.jsonl')} view_rows=list(rows(destination/'public/test/views.jsonl')) byepisode={e['episode_id']:e for e in episodes} bygroup={g['group_id']:g for g in rows(root/'private/recipes.jsonl')} if (root/'private/recipes.jsonl').exists() else { read(p)['group_id']:read(p) for p in (root/'private/plans').glob('*.json')} if len(inputs)!=len({s['sample_id'] for s in inputs}) or set(prompts)!=set(gold) or len(gold)!=len(inputs): raise ValueError('Sample, prompt and answer identities differ') if not pilot and (len(episodes)!=2000 or len({e['scene_id'] for e in episodes})!=100): raise ValueError('Wrong final physical/hall count') hall_counts=Counter(e['scene_id'] for e in episodes) if not pilot and set(hall_counts.values())!={20}: raise ValueError('A hall does not contain exactly 20 episodes') for episode in episodes: group=bygroup[episode['episode_group_id']] if audit_geometry(episode,group['room'],episode['family_type']=='count') is None: raise ValueError('Geometry or range ambiguity audit failed') expected=list(views(episode)) actual=[v for v in view_rows if v['episode_id']==episode['episode_id']] if len(actual)!=len(expected) or {(v['setting'],tuple(v['receiver_ids'])) for v in actual}!={(v['setting'],tuple(v['receiver_ids'])) for v in expected}: raise ValueError('Incorrect single-receiver/full-cloud views') for human in episode['humans']: event=human['events'][0] if event['end_sample']>episode['duration_samples']-round(2.25*SR): raise ValueError('Insufficient human reverberation tail budget') if human['source_quality']['maximum_internal_silence_s']>.35: raise ValueError('Discontinuous target speech') for source in episode['playback_sources']: robot=next(r for r in episode['robots'] if r['entity_id']==source['entity_id']) if source['entity_id']=='R01': raise ValueError('R01 playback role changed') if any(source[k]!=robot[k] for k in ['initial_xyz_m','displacement_m','motion_start_s','motion_duration_s','yaw_deg']): raise ValueError('Playback did not follow its robot') for recording in recordings.values(): path=destination/recording['path'] if sha(path)!=recording['sha256']: raise ValueError('Published FOA checksum mismatch') wave,rate=sf.read(path,dtype='float32') if wave.shape!=(recording['num_samples'],4) or rate!=SR or not np.isfinite(wave).all() or float(np.max(np.abs(wave)))>.900001: raise ValueError('Invalid published FOA shape/amplitude') for sample in inputs: g=gold[sample['sample_id']] episode=byepisode[sample['episode_id']] if sample['mode']!=mode or sample['scene_id']!=episode['scene_id']: raise ValueError('Hall/episode/mode identity mismatch') if sample['setting']=='cloud' and sample['receiver_ids']!=[r['entity_id'] for r in episode['robots']]: raise ValueError('Cloud does not contain all robots') for binding in sample['audio_bindings']: record=recordings[binding['recording_id']] if binding['path']!=record['path'] or binding['sha256']!=record['sha256'] or record['episode_id']!=sample['episode_id']: raise ValueError('Question bound to the wrong receiver recording') if prompts[sample['sample_id']]['rendered_prompt']!=render(sample): raise ValueError('Prompt does not match public metadata') if mode=='dynamic' and g['expected_times_s']!=[s/SR for s in grid(episode)]: raise ValueError('Dynamic answer has an incorrect 0.5-second grid') if sample['task_id']=='KW_ASR': phrase=tokens(sample['query']['wake_phrase']) hits=[h for h in episode['humans'] if tokens(h['events'][0]['text'])[:len(phrase)]==phrase] if len(hits)>1: raise ValueError('Multi-human wake prefix was generated') expected=' '.join(e['text'] for e in hits[0]['events']) if hits else '' if g['output']!=expected: raise ValueError('Wake-prefix target or full transcription mismatch') if sample['task_id']=='C2_REGION_ASR': members=region_members(episode,sample['query']['region']) if members is None or len(members)>1 or (g['output']=='' and members): raise ValueError('Region boundary or target ambiguity') expected=next((' '.join(e['text'] for e in h['events']) for h in episode['humans'] if h['entity_id'] in members),'') if g['output']!=expected: raise ValueError('Region transcription does not match its human target') task=sample['task_id'] target=next((h for h in episode['humans'] if h['entity_id']==g['target_source_id']),None) receiver=next((r for r in episode['robots'] if r['entity_id']==sample['reference_robot_id']),None) if task=='DOA_TRAJECTORY': expected=dict(tracks=[dict(track_id=h['entity_id'],frames=frames(episode,h,receiver,'doa_deg')) for h in episode['humans']]) elif task in ['RANGE_TRAJECTORY','TEXT_TRAJECTORY']: expected=dict(frames=frames(episode,target,receiver,'distance_m') if task=='RANGE_TRAJECTORY' else frames(episode,target)) elif task=='DOA': sources=episode['humans']+[s for s in episode['playback_sources'] if s['entity_id']!=sample['reference_robot_id']] expected=[geometry(s,receiver,0.)['doa_deg'] for s in sources] elif task in ['RANGE','TEXT_DOA']: expected=geometry(target,receiver,0.)['distance_m' if task=='RANGE' else 'doa_deg'] elif task=='C1_SETLOC': expected=[h['initial_xyz_m'] for h in episode['humans']] elif task=='C3_TEXTLOC': expected=target['initial_xyz_m'] elif task=='DOA_ASR': expected=' '.join(e['text'] for e in target['events']) else: expected=g['output'] if g['output']!=expected: raise ValueError('Speaker/receiver geometry or task reference mismatch') # Common count variants really reuse the same single-receiver audio, not # just similar recipes. All robot playback is disabled in this family. count_groups=defaultdict(list) for episode in episodes: if episode['family_type']=='count': count_groups[(episode['episode_group_id'],len(episode['humans']))].append(episode) for related in count_groups.values(): for rid in ['R01','R02']: selected=[e for e in related if rid in [r['entity_id'] for r in e['robots']]] hashes={next(r['sha256'] for r in recordings.values() if r['episode_id']==e['episode_id'] and r['receiver_robot_id']==rid) for e in selected} if len(hashes)>1: raise ValueError('Robot-count control changed a common recording') report=dict(passed=True,halls=len(hall_counts),physical_episodes=len(episodes),questions=len(inputs), recordings=len(recordings),views=len(view_rows),label_step_s=.5 if mode=='dynamic' else None, exact_count_audio_correspondence=True,human_listening_audit_completed=False,model_inference_performed=False) write(destination/'reports/acceptance.json',report) return report def finalize(root): from dynamic_dataset.runtime import ensure_compute ensure_compute() root=Path(root).resolve() groups=list(rows(root/'private/recipes.jsonl')) if not read(root/'reports/preflight.complete.json')['passed']: raise ValueError('Full recipe/task preflight must pass before release') if len(groups)!=300: raise ValueError('Incomplete 100-hall plan') for mode in ['static','dynamic']: completed=read(root/mode/'reports/render.complete.json') if not completed['passed'] or completed['groups']!=300: raise ValueError('Cannot freeze incomplete rendering') for index,group in enumerate(groups): normalize_family(root,group) if index%20==0: print('JOINT NORMALIZATION',index,'/ 300',flush=True) acceptance={} for mode in ['static','dynamic']: destination=root/mode for name,target in [('assets/rooms',root/'shared/rooms'),('assets/noise',root/'shared/noise')]: link=destination/'public'/name link.parent.mkdir(parents=True,exist_ok=True) if not link.exists(): link.symlink_to(target,target_is_directory=True) export(root,mode) build_index(destination) acceptance[mode]=audit(root,mode) scoring_selftest(destination) recipes=root/'private/reproduction/recipes.jsonl.gz' recipes.parent.mkdir(parents=True,exist_ok=True) with gzip.open(recipes,'wt') as stream: for group in groups: stream.write(json.dumps(group,separators=(',',':'),allow_nan=False)+'\n') native=Path(__file__).parent.parent/'dynamic_demo/render.py' repo=Path(__file__).parent.parent dependencies=['dynamic_dataset/common.py','dynamic_dataset/prepare.py','dynamic_dataset/frame_score.py', 'dynamic_dataset/score.py','dynamic_demo/common.py','dynamic_demo/render.py', 'generation/native/build_static_v1_scene.py'] try: revision=subprocess.check_output(['git','rev-parse','HEAD'],cwd=repo,text=True).strip() except (OSError,subprocess.CalledProcessError): revision=None environment=dict(python=sys.version,packages={name:importlib.metadata.version(name) for name in ['numpy','scipy','soundfile','numpy-quaternion']}, native_protocol=read(Path(__file__).parent.parent/'generation/configs/native_environment.json')) write(root/'provenance/environment.json',environment) from .sources import SILERO_REVISION,SILERO_SHA256,ESC_REVISION lock=dict(schema_version=VERSION,config=read(root/'config.json'),code_sha256=code_hashes(), repository_revision=revision,shared_dependency_sha256={name:sha(repo/name) for name in dependencies}, native_renderer_sha256=sha(native),recipes_sha256=sha(recipes), room_manifest_sha256=sha(root/'private/rooms.jsonl'),noise_manifest_sha256=sha(root/'shared/noise/catalog.jsonl'), environment=environment,noise_source_revision=ESC_REVISION, speech_screening_model_revision=SILERO_REVISION,speech_screening_model_sha256=SILERO_SHA256) write(root/'reproduction.lock.json',lock) import shutil shutil.copyfile(Path(__file__).parent/'README.zh.md',root/'README.zh.md') snapshot=root/'private/reproduction/code' snapshot.mkdir(parents=True,exist_ok=True) for path in Path(__file__).parent.iterdir(): if path.suffix in ['.py','.sh','.md','.txt']: shutil.copyfile(path,snapshot/path.name) for mode in ['static','dynamic']: write(root/mode/'release.complete.json',dict(passed=True,mode=mode,halls=100,physical_episodes=2000, label_step_s=.5 if mode=='dynamic' else None,source_rir_step_s=.2,receiver_rir_step_s=.2, acceptance=acceptance[mode],scorer_selftest_passed=True)) write(root/'release.complete.json',dict(passed=True,halls=100,static_physical_episodes=2000,dynamic_physical_episodes=2000, acceptance=acceptance,label_step_s=.5,source_rir_step_s=.2,receiver_rir_step_s=.2, code_sha256=code_hashes(),model_inference_performed=False,human_listening_audit_completed=False)) print('RELEASE COMPLETE: 2000 STATIC + 2000 DYNAMIC',flush=True) if __name__=='__main__': parser=argparse.ArgumentParser() parser.add_argument('--root',type=Path,required=True) finalize(parser.parse_args().root)