experiments/exp4_fix.py

#!/usr/bin/env python3
"""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}')
        # Fallback: generate synthetic audio
        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)

    # PAVO Adaptive
    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()