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