Update walltime estimation

config.py

@@ -63,21 +63,33 @@ NGRAM_INDEX_PATH = DATA_PATH / f"phoneme_ngram_index_{NGRAM_SIZE}.pkl"
 # Inference settings
 # =============================================================================
 
-# VAD lease: linear regression from 121 GPU runs (R²=0.992)
+# VAD lease: linear regression from 203 GPU runs (R²=0.996)
+# vad_gpu = 0.284 * minutes + 1.80; max residual +2.17s
 def get_vad_duration(minutes):
     """GPU seconds needed for VAD based on audio minutes."""
-    VAD_LEASE_BUFFER = 6  # safety margin over regression (seconds)
-    return max(3, 0.3 * minutes + VAD_LEASE_BUFFER)
+    VAD_LEASE_BUFFER = 3  # covers max residual (2.17s) with margin
+    return max(3, 0.284 * minutes + 1.80 + VAD_LEASE_BUFFER)
 
 def get_asr_duration(minutes, model_name="Base"):
-    """GPU seconds needed for ASR.
-    """
+    """GPU seconds needed for ASR (constant, independent of audio duration)."""
     if model_name == "Large":
-        return 15
-    return 7
-
-ESTIMATE_ALIGNMENT_OVERHEAD_S = 4  # DP alignment + result building + gpu queue
-ESTIMATE_CPU_MULTIPLIER = 50
+        return 10  # max observed 8.43s (n=32)
+    return 5      # max observed 4.63s (n=177)
+
+# Wall-time estimation: direct regression on total time (not sum of leases)
+# GPU Base:  total = 0.43 * minutes + 5.5  (R²=0.89, n=177)
+# GPU Large: total = 0.50 * minutes + 11.2 (R²=0.20, n=32)
+# CPU Base:  total = 11.2 * minutes + 20.9 (R²=0.46, n=37)
+# CPU Large: total = 25.2 * minutes + 24.4 (R²=0.67, n=11)
+ESTIMATE_GPU_BASE_SLOPE = 0.43
+ESTIMATE_GPU_BASE_INTERCEPT = 5.5
+ESTIMATE_GPU_LARGE_SLOPE = 0.50
+ESTIMATE_GPU_LARGE_INTERCEPT = 11.2
+ESTIMATE_CPU_BASE_SLOPE = 11.2
+ESTIMATE_CPU_BASE_INTERCEPT = 20.9
+ESTIMATE_CPU_LARGE_SLOPE = 25.2
+ESTIMATE_CPU_LARGE_INTERCEPT = 24.4
+ESTIMATE_WALL_BUFFER = 1.5  # multiplier on regression to cover variance
 
 # Batching strategy
 BATCHING_STRATEGY = "dynamic"  # "naive" (fixed count) or "dynamic" (seconds + pad waste)

src/api/session_api.py

@@ -216,10 +216,17 @@ def _load_session_metadata(audio_id):
 
 def estimate_duration(endpoint, audio_duration_s=None, audio_id=None,
                       model_name="Base", device="GPU"):
-    """Estimate processing duration for a given endpoint."""
+    """Estimate processing duration for a given endpoint.
+
+    Uses direct wall-time regression (not sum of lease components) fitted on
+    257 runs from hetchyy/quran-aligner-logs v1 dataset.
+    """
     from config import (
-        get_vad_duration, get_asr_duration,
-        ESTIMATE_ALIGNMENT_OVERHEAD_S, ESTIMATE_CPU_MULTIPLIER,
+        ESTIMATE_GPU_BASE_SLOPE, ESTIMATE_GPU_BASE_INTERCEPT,
+        ESTIMATE_GPU_LARGE_SLOPE, ESTIMATE_GPU_LARGE_INTERCEPT,
+        ESTIMATE_CPU_BASE_SLOPE, ESTIMATE_CPU_BASE_INTERCEPT,
+        ESTIMATE_CPU_LARGE_SLOPE, ESTIMATE_CPU_LARGE_INTERCEPT,
+        ESTIMATE_WALL_BUFFER,
         MFA_PROGRESS_SEGMENT_RATE,
     )
 
@@ -261,16 +268,26 @@ def estimate_duration(endpoint, audio_duration_s=None, audio_id=None,
         num_segments = len(segments)
         estimate = MFA_PROGRESS_SEGMENT_RATE * num_segments
     else:
-        # --- Pipeline endpoints: VAD + ASR + alignment overhead ---
-        estimate = 0.0
-        if endpoint in _VAD_ENDPOINTS:
-            estimate += get_vad_duration(minutes)
-        estimate += get_asr_duration(minutes, model_name)
-        estimate += ESTIMATE_ALIGNMENT_OVERHEAD_S
-
-    # --- CPU multiplier ---
-    if device == "CPU":
-        estimate *= ESTIMATE_CPU_MULTIPLIER
+        # --- Pipeline endpoints: direct wall-time regression ---
+        device_upper = (device or "GPU").upper()
+        is_large = model_name == "Large"
+
+        if device_upper == "CPU":
+            if is_large:
+                estimate = ESTIMATE_CPU_LARGE_SLOPE * minutes + ESTIMATE_CPU_LARGE_INTERCEPT
+            else:
+                estimate = ESTIMATE_CPU_BASE_SLOPE * minutes + ESTIMATE_CPU_BASE_INTERCEPT
+        else:
+            if is_large:
+                estimate = ESTIMATE_GPU_LARGE_SLOPE * minutes + ESTIMATE_GPU_LARGE_INTERCEPT
+            else:
+                estimate = ESTIMATE_GPU_BASE_SLOPE * minutes + ESTIMATE_GPU_BASE_INTERCEPT
+
+        # Retranscribe/realign skip VAD — scale down by ~50% (ASR+DP only)
+        if endpoint not in _VAD_ENDPOINTS:
+            estimate *= 0.5
+
+        estimate *= ESTIMATE_WALL_BUFFER
 
     rounded = max(5, math.ceil(estimate / 5) * 5)