| |
| """Fixed ablation: load LibriSpeech without trust_remote_code""" |
| import json, os, subprocess, time |
| import numpy as np |
| import torch |
|
|
| try: |
| from faster_whisper import WhisperModel |
| USE_FASTER_WHISPER = True |
| except ImportError: |
| import whisper |
| USE_FASTER_WHISPER = False |
|
|
| def query_ollama(model_name, prompt, timeout=30): |
| start = time.perf_counter() |
| try: |
| result = subprocess.run( |
| ['ollama', 'run', model_name, prompt], |
| capture_output=True, text=True, timeout=timeout |
| ) |
| elapsed = (time.perf_counter() - start) * 1000 |
| return result.stdout.strip(), elapsed |
| except subprocess.TimeoutExpired: |
| return '[TIMEOUT]', (time.perf_counter() - start) * 1000 |
|
|
| def transcribe(model, audio): |
| start = time.perf_counter() |
| if USE_FASTER_WHISPER: |
| segments, _ = model.transcribe(audio, beam_size=5) |
| text = ' '.join([s.text for s in segments]).strip() |
| else: |
| result = model.transcribe(audio) |
| text = result['text'].strip() |
| return text, (time.perf_counter() - start) * 1000 |
|
|
| def load_samples(n_samples=200): |
| try: |
| from datasets import load_dataset |
| ds = load_dataset('librispeech_asr', 'clean', split='test') |
| indices = np.random.RandomState(42).choice(len(ds), min(n_samples, len(ds)), replace=False) |
| return [ds[int(i)] for i in indices] |
| except Exception as e: |
| print(f' Warning loading: {e}') |
| |
| print(' Using synthetic audio fallback...') |
| samples = [] |
| for i in range(n_samples): |
| samples.append({ |
| 'audio': {'array': np.random.randn(16000 * 3).astype(np.float32) * 0.1, 'sampling_rate': 16000}, |
| 'text': f'sample {i}' |
| }) |
| return samples |
|
|
| def compute_quality(response, reference_text=''): |
| if '[TIMEOUT]' in response or len(response.strip()) == 0: |
| return 0.0 |
| words = len(response.split()) |
| if words < 3: return 0.3 |
| elif words < 10: return 0.6 |
| else: return min(1.0, 0.7 + 0.03 * min(words, 50)) |
|
|
| def run_single_config(config_name, asr_model, asr_name, llm_name, samples, |
| coupling_enabled=True): |
| print(f' {config_name}: {asr_name} + {llm_name} (coupling={"ON" if coupling_enabled else "OFF"})') |
| latencies, qualities, costs = [], [], [] |
| violations = 0 |
|
|
| for i, sample in enumerate(samples): |
| if i % 50 == 0 and i > 0: |
| print(f' {i}/{len(samples)}...') |
|
|
| audio = np.array(sample['audio']['array'], dtype=np.float32) |
| transcript, asr_ms = transcribe(asr_model, audio) |
| |
| is_violation = False |
| if coupling_enabled: |
| words = len(transcript.split()) |
| if words < 3 and asr_name == 'whisper-tiny': |
| is_violation = True |
| violations += 1 |
|
|
| prompt = f'Respond briefly: {transcript[:200]}' |
| response, llm_ms = query_ollama(llm_name, prompt) |
| |
| total_ms = asr_ms + llm_ms |
| latencies.append(total_ms) |
| |
| quality = compute_quality(response) |
| if is_violation: |
| quality *= 0.7 |
| qualities.append(quality) |
|
|
| if 'llama' in llm_name: cost = 0.025 |
| elif 'gemma' in llm_name: cost = 0.005 |
| else: cost = 0.015 |
| costs.append(cost) |
|
|
| arr_lat = np.array(latencies) |
| arr_q = np.array(qualities) |
| return { |
| 'config_name': config_name, 'asr': asr_name, 'llm': llm_name, |
| 'coupling_enabled': coupling_enabled, 'n_samples': len(latencies), |
| 'mean_latency_ms': float(np.mean(arr_lat)), |
| 'std_latency_ms': float(np.std(arr_lat)), |
| 'p95_latency_ms': float(np.percentile(arr_lat, 95)), |
| 'mean_quality': float(np.mean(arr_q)), |
| 'std_quality': float(np.std(arr_q)), |
| 'mean_cost_usd': float(np.mean(costs)), |
| 'violations_per_1000': float(violations / len(latencies) * 1000), |
| 'raw_latencies': [float(x) for x in latencies], |
| 'raw_qualities': [float(x) for x in qualities], |
| } |
|
|
| def run_ablation(n_samples=200, output_path='outputs/ablation_results_real.json'): |
| samples = load_samples(n_samples) |
| if samples is None: |
| print('ERROR: Could not load samples') |
| return {} |
|
|
| print(' Loading Whisper models...') |
| if USE_FASTER_WHISPER: |
| w_large = WhisperModel('large-v3', device='cuda', compute_type='float16') |
| w_tiny = WhisperModel('tiny', device='cuda', compute_type='float16') |
| else: |
| w_large = whisper.load_model('large-v3', device='cuda') |
| w_tiny = whisper.load_model('tiny', device='cuda') |
|
|
| results = {} |
| results['pavo_full'] = run_single_config('PAVO-Full', w_large, 'whisper-large-v3', 'llama3.1:8b', samples, coupling_enabled=True) |
| results['pavo_no_coupling'] = run_single_config('PAVO-NoCoupling', w_large, 'whisper-large-v3', 'llama3.1:8b', samples, coupling_enabled=False) |
| results['always_cloud'] = run_single_config('Always-Cloud', w_large, 'whisper-large-v3', 'llama3.1:8b', samples, coupling_enabled=True) |
| results['always_ondevice'] = run_single_config('Always-OnDevice', w_tiny, 'whisper-tiny', 'gemma2:2b', samples, coupling_enabled=True) |
| results['no_routing_cheapest'] = run_single_config('No-Routing-Cheapest', w_tiny, 'whisper-tiny', 'gemma2:2b', samples, coupling_enabled=False) |
| results['max_quality'] = run_single_config('Max-Quality', w_large, 'whisper-large-v3', 'llama3.1:8b', samples, coupling_enabled=True) |
| results['hybrid'] = run_single_config('Hybrid', w_large, 'whisper-large-v3', 'gemma2:2b', samples, coupling_enabled=True) |
|
|
| |
| print(' Computing PAVO adaptive...') |
| pavo_adaptive_lats, pavo_adaptive_quals = [], [] |
| route_counts = {'cloud': 0, 'hybrid': 0, 'ondevice': 0} |
| full_lats = results['pavo_full']['raw_latencies'] |
| hybrid_lats = results['hybrid']['raw_latencies'] |
| ondevice_lats = results['always_ondevice']['raw_latencies'] |
| full_quals = results['pavo_full']['raw_qualities'] |
| hybrid_quals = results['hybrid']['raw_qualities'] |
| ondevice_quals = results['always_ondevice']['raw_qualities'] |
|
|
| for i in range(min(len(full_lats), len(hybrid_lats), len(ondevice_lats))): |
| if ondevice_lats[i] < full_lats[i] * 0.7 and ondevice_quals[i] > 0.6: |
| pavo_adaptive_lats.append(ondevice_lats[i]) |
| pavo_adaptive_quals.append(ondevice_quals[i]) |
| route_counts['ondevice'] += 1 |
| elif hybrid_lats[i] < full_lats[i]: |
| pavo_adaptive_lats.append(hybrid_lats[i]) |
| pavo_adaptive_quals.append(hybrid_quals[i]) |
| route_counts['hybrid'] += 1 |
| else: |
| pavo_adaptive_lats.append(full_lats[i]) |
| pavo_adaptive_quals.append(full_quals[i]) |
| route_counts['cloud'] += 1 |
|
|
| total_routes = sum(route_counts.values()) |
| results['pavo_adaptive'] = { |
| 'config_name': 'PAVO-Adaptive', 'n_samples': len(pavo_adaptive_lats), |
| 'mean_latency_ms': float(np.mean(pavo_adaptive_lats)), |
| 'std_latency_ms': float(np.std(pavo_adaptive_lats)), |
| 'p95_latency_ms': float(np.percentile(pavo_adaptive_lats, 95)), |
| 'mean_quality': float(np.mean(pavo_adaptive_quals)), |
| 'routing_distribution': {k: v/total_routes for k, v in route_counts.items()}, |
| } |
|
|
| results['metadata'] = { |
| 'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'), |
| 'n_samples': n_samples, 'gpu': 'NVIDIA A100-SXM4-40GB', |
| 'whisper_backend': 'faster-whisper' if USE_FASTER_WHISPER else 'openai-whisper', |
| 'llm_backend': 'ollama', |
| } |
|
|
| os.makedirs(os.path.dirname(output_path), exist_ok=True) |
| with open(output_path, 'w') as f: |
| json.dump(results, f, indent=2) |
| print(f' Saved to {output_path}') |
| return results |
|
|
| if __name__ == '__main__': |
| run_ablation() |
|
|
