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