#!/usr/bin/env python3 """AuroraASR-1M lightweight macOS runtime. Dependencies: numpy soundfile sentencepiece, plus optional scipy for resampling, soxr (HQ reference resampling); onnxruntime / onnxruntime-ep-mlx OR coremltools. Exports contain the acoustic model only; this reproduces upstream log-mel + greedy CTC. """ import argparse import json import math import platform import time from functools import lru_cache from pathlib import Path import numpy as np @lru_cache(maxsize=8) def mel_filterbank(sr=16000, n_fft=512, n_mels=80, fmin=20.0, fmax=8000.0): def hz2mel(f): return 2595.0 * np.log10(1.0 + f / 700.0) def mel2hz(m): return 700.0 * (10.0 ** (m / 2595.0) - 1.0) edges = mel2hz(np.linspace(hz2mel(fmin), hz2mel(fmax), n_mels + 2)) frequencies = np.linspace(0, sr / 2, n_fft // 2 + 1) bank = np.zeros((n_mels, frequencies.size), np.float32) for k in range(n_mels): left, center, right = edges[k:k + 3] rise = (frequencies - left) / (center - left) fall = (right - frequencies) / (right - center) bank[k] = np.maximum(0.0, np.minimum(rise, fall)) if bank[k].sum() == 0: bank[k, int(np.argmin(np.abs(frequencies - center)))] = 1.0 return bank def features(audio, sr=16000, *, n_fft=512, win_length=400, hop_length=160, n_mels=80, fmin=20.0, fmax=8000.0): """Match AuroraASRFeatureExtractor: reflect STFT, periodic Hann, per-bin unbiased std.""" if sr != 16000: raise ValueError('Resample audio to 16000 Hz before feature extraction') wave = np.asarray(audio, dtype=np.float32) if wave.ndim != 1 or wave.size < n_fft // 2 + 1: raise ValueError('Expected mono audio with at least 257 samples') padded = np.pad(wave, (n_fft // 2, n_fft // 2), mode='reflect') frames = np.lib.stride_tricks.sliding_window_view(padded, n_fft)[::hop_length] # torch.hann_window(win_length) is periodic; centered in n_fft STFT window. window = np.hanning(win_length + 1)[:-1] left = (n_fft - win_length) // 2 window = np.pad(window, (left, n_fft - win_length - left)) spectrum = np.fft.rfft(frames * window[None, :], n=n_fft, axis=-1) power = spectrum.real ** 2 + spectrum.imag ** 2 bank = mel_filterbank(sr, n_fft, n_mels, fmin, fmax) logmel = np.log(power @ bank.T + 1e-10) normalized = (logmel - logmel.mean(axis=0, keepdims=True)) / ( logmel.std(axis=0, ddof=1, keepdims=True) + 1e-5) return np.ascontiguousarray(normalized[None].astype(np.float32)) @lru_cache(maxsize=4) def load_sentencepiece(model_file): import sentencepiece as spm return spm.SentencePieceProcessor(model_file=str(model_file)) def ctc_text(logits, spm_path, blank_id=0): sp = load_sentencepiece(str(Path(spm_path).expanduser().resolve())) path = np.asarray(logits).argmax(axis=-1)[0].astype(np.int64) distinct = np.ones(path.size, dtype=bool) distinct[1:] = path[1:] != path[:-1] ids = [int(x) - 1 for x in path[distinct] if int(x) != blank_id] return sp.decode(ids) def load_model(model_dir, backend='cpu', precision='fp32', dynamic=False, compute_unit='all'): model_dir = Path(model_dir) if backend in ('cpu', 'mlx'): import onnxruntime as ort path = model_dir / ('aurora_dynamic.onnx' if dynamic else 'aurora_asr.onnx') if not path.exists(): raise FileNotFoundError(f'Missing {path}; dynamic export must pass Colab parity first') if backend == 'mlx': import onnxruntime_ep_mlx onnxruntime_ep_mlx.register_execution_provider_library() providers = ['MLXExecutionProvider', 'CPUExecutionProvider'] else: providers = ['CPUExecutionProvider'] sess = ort.InferenceSession(str(path), providers=providers) if backend == 'mlx' and 'MLXExecutionProvider' not in sess.get_providers(): raise RuntimeError('MLX plugin was not registered; refusing to report MLX speed') name = sess.get_inputs()[0].name shape = sess.get_inputs()[0].shape def infer(x): if isinstance(shape[1], int) and x.shape[1] != shape[1]: raise ValueError(f'Model is static at {shape}; requested {x.shape}. Use a matching clip or --dynamic.') return sess.run(None, {name: x})[0] return infer, {'providers':sess.get_providers(), 'model':path.name} if backend == 'coreml': import coremltools as ct package = model_dir / f'aurora_{precision}.mlpackage' if not package.is_dir() or not (package/'Manifest.json').exists(): raise FileNotFoundError( f'Core ML package missing: {package.resolve()}. ' 'Use the sibling AuroraASR-1M-CoreML export instead of the MLX export.') units = {'all':ct.ComputeUnit.ALL, 'cpu':ct.ComputeUnit.CPU_ONLY, 'gpu':ct.ComputeUnit.CPU_AND_GPU}[compute_unit] mdl = ct.models.MLModel(str(package), compute_units=units) name = mdl.get_spec().description.input[0].name out_name = mdl.get_spec().description.output[0].name expected = tuple(mdl.get_spec().description.input[0].type.multiArrayType.shape) def infer(x): if tuple(x.shape) != expected: raise ValueError(f'Core ML package has static input {expected}, got {x.shape}') return np.asarray(mdl.predict({name:x})[out_name]) return infer, {'compute_units_requested':compute_unit, 'ane_placement_verified':False, 'model':package.name} raise ValueError(f'Invalid backend: {backend}') def read_audio(filename, resampler='soxr_hq'): """Read/mono/resample identically to the v3 reference path by default.""" import soundfile as sf wave, sr = sf.read(str(filename), dtype='float32') if wave.ndim == 2: wave = wave.mean(axis=1) if sr != 16000: if resampler == 'soxr_hq': import soxr wave = soxr.resample(wave, sr, 16000, quality='HQ').astype(np.float32) elif resampler == 'scipy_poly': from scipy.signal import resample_poly gcd = math.gcd(int(sr), 16000) wave = resample_poly(wave, 16000 // gcd, int(sr) // gcd).astype(np.float32) else: raise ValueError('Unknown resampler') sr = 16000 return wave, sr def main(): p = argparse.ArgumentParser(description=__doc__) p.add_argument('--model-dir', type=Path, required=True) p.add_argument('--audio', type=Path, required=True) p.add_argument('--backend', choices=['cpu','mlx','coreml'], default='cpu') p.add_argument('--precision', choices=['fp32','fp16'], default='fp32') p.add_argument('--compute-unit', choices=['all','cpu','gpu'], default='all') p.add_argument('--dynamic', action='store_true') p.add_argument('--resampler', choices=['soxr_hq','scipy_poly'], default='soxr_hq') p.add_argument('--warmup', type=int, default=8) p.add_argument('--runs', type=int, default=40) args = p.parse_args() # The recorded file I/O latency can vary by seconds (cold cache, external volumes). read_start = time.perf_counter() wave, sr = read_audio(args.audio, args.resampler) audio_seconds = len(wave) / sr io_ms = (time.perf_counter() - read_start) * 1000 fe_start = time.perf_counter() config = json.loads((args.model_dir/'upstream_reference'/'config.json').read_text()) feat = features(wave, sr, n_fft=config.get('n_fft',512), win_length=config.get('win_length',400), hop_length=config.get('hop_length',160), n_mels=config.get('n_mels',80)) feature_ms = (time.perf_counter() - fe_start) * 1000 model_start = time.perf_counter() runner, details = load_model(args.model_dir, args.backend, args.precision, args.dynamic, args.compute_unit) model_load_ms = (time.perf_counter() - model_start) * 1000 st = time.perf_counter() logits = runner(feat) first_inference_ms = (time.perf_counter() - st) * 1000 if logits.ndim != 3 or logits.shape[0] != 1 or logits.shape[-1] != 257: raise RuntimeError(f'Unexpected CTC logits: {logits.shape}') # Do not benchmark the first inference: Core ML / MLX may compile or specialize. for _ in range(max(0,args.warmup)): warm_logits = runner(feat) timings = [] for _ in range(max(1,args.runs)): st = time.perf_counter(); warm_logits = runner(feat) timings.append((time.perf_counter() - st) * 1000) if not np.array_equal(np.argmax(logits,axis=-1),np.argmax(warm_logits,axis=-1)): raise RuntimeError('First-vs-warm CTC output changed; investigate backend determinism') # Separate first tokenizer load (disk/initialization) from warm decode cost. spm_file=args.model_dir/'upstream_reference'/'bpe256.model' st = time.perf_counter() text = ctc_text(warm_logits, spm_file, config.get('blank_token_id',0)) first_decode_ms=(time.perf_counter()-st)*1000 decode_times=[] for _ in range(max(5,min(20,args.runs))): st=time.perf_counter() decoded=ctc_text(warm_logits,spm_file,config.get('blank_token_id',0)) decode_times.append((time.perf_counter()-st)*1000) if decoded!=text: raise RuntimeError('CTC output changed on repeated decode') warm_decode_ms=float(np.median(decode_times)) warm_median_ms = float(np.median(timings)) warm_pipeline_ms = feature_ms + warm_median_ms + warm_decode_ms # Actually exercise a whole frontend+acoustic+CTC warm run. No disk I/O. def pipeline_once(): x=features(wave,sr,n_fft=config.get('n_fft',512), win_length=config.get('win_length',400),hop_length=config.get('hop_length',160), n_mels=config.get('n_mels',80)) return ctc_text(runner(x),spm_file,config.get('blank_token_id',0)) for _ in range(3): if pipeline_once()!=text: raise RuntimeError('Whole-pipeline CTC mismatch between repeated passes') pipeline_times=[] for _ in range(max(5,min(20,args.runs))): st=time.perf_counter(); t=pipeline_once();pipeline_times.append((time.perf_counter()-st)*1000) if t!=text:raise RuntimeError('Whole-pipeline transcript changed') print(json.dumps({'backend':args.backend,'precision':args.precision,'shape':list(feat.shape), 'text':text, 'resampler':args.resampler,'audio_seconds':audio_seconds, 'file_io_ms':io_ms,'feature_ms':feature_ms,'model_load_ms':model_load_ms, 'acoustic_first_inference_ms':first_inference_ms, 'acoustic_warm_p50_ms':warm_median_ms, 'acoustic_warm_p95_ms':float(np.percentile(timings,95)), 'ctc_decode_first_ms':first_decode_ms, 'ctc_decode_warm_p50_ms':warm_decode_ms, 'warm_whole_pipeline_p50_ms':float(np.median(pipeline_times)), 'warm_whole_pipeline_p95_ms':float(np.percentile(pipeline_times,95)), 'warm_pipeline_estimate_excluding_io_and_model_load_ms':warm_pipeline_ms, 'warm_pipeline_estimate_rtf':warm_pipeline_ms/(audio_seconds*1000), 'warning':'Warm whole-pipeline measures repeated same-file in-memory runs; test separate real clips for actual workload performance.', 'backend_details':details},indent=2)) if __name__ == '__main__': main()