Upload inference.py with huggingface_hub

inference.py

@@ -110,48 +110,40 @@ def calculate_bpm(y, sr):
     """
     Extract BPM and cardiac cycle count from a PCG recording.
 
+    Uses TWO complementary methods:
+    1. Envelope peak detection — reliable for normal/slow rates, provides peak positions
+    2. Autocorrelation — robust at ALL heart rates, used to validate/correct BPM
+
     Key clinical considerations:
     - Each cardiac cycle produces TWO sounds: S1 (lub) and S2 (dup)
-    - Naive peak detection counts both → doubles the BPM (the main bug fixed here)
-    - Fix: use envelope smoothing + long refractory window to detect only S1 peaks
-    - Valid canine heart rate range: 40–180 BPM
+    - Peak detection with refractory window detects only S1 peaks
+    - Autocorrelation finds the dominant cycle period (S1-to-S1) naturally
+    - Valid canine heart rate range: 40–250 BPM
     """
     try:
         # ── 1. RMS Noise Gate ──────────────────────────────────────────────────
-        # Skip analysis if the signal is too quiet (microphone not placed yet)
         rms = np.sqrt(np.mean(y ** 2))
         if rms < 0.01:
             return 0, 0, np.array([])
 
         # ── 2. Multi-scale Hilbert Envelope ───────────────────────────────────
-        # Compute the analytic envelope, then smooth at TWO scales:
-        # - Fine scale (40ms): remove HF noise within each sound
-        # - Coarse scale (80ms): merge S1+S2 but keep fast beats separable
-        #   (was 120ms — too wide for tachycardic cases, merged adjacent beats)
         envelope = np.abs(scipy.signal.hilbert(y))
 
-        fine_len = int(0.04 * sr) | 1        # 40 ms, must be odd
-        coarse_len = int(0.08 * sr) | 1      # 80 ms, must be odd
+        fine_len = int(0.05 * sr) | 1        # 50 ms, must be odd
+        coarse_len = int(0.12 * sr) | 1      # 120 ms, must be odd
 
         fine_env   = scipy.signal.savgol_filter(envelope, fine_len,   polyorder=2)
         coarse_env = scipy.signal.savgol_filter(fine_env, coarse_len, polyorder=2)
         coarse_env = np.clip(coarse_env, 0, None)
 
         # ── 3. Adaptive Height Threshold ──────────────────────────────────────
-        # Height = 35% of the 90th percentile of the coarse envelope.
-        # Slightly lower than before (was 40%) to catch fast, lower-amplitude beats.
         v90    = np.percentile(coarse_env, 90)
-        height = v90 * 0.35
-
-        # ── 4. Two-Pass Peak Detection ────────────────────────────────────────
-        # PASS 1: Detect ALL candidate peaks with a short minimum distance.
-        # At 240 BPM → cycle = 250ms. Use 200ms minimum to catch everything.
-        min_dist_samp = int(0.20 * sr)  # 200ms → supports up to 300 BPM
+        height = v90 * 0.40
 
-        # Prominence filter: each detected peak must stand at least 25% of
-        # the local envelope height above its neighbours → eliminates noise
-        # but preserves rapid S1 peaks (was 30%, too aggressive for tachy).
-        prominence = v90 * 0.25
+        # ── 4. Peak Detection (proven parameters for normal/slow rates) ───────
+        min_dist_sec  = 0.50           # 500 ms → max 120 BPM via peaks
+        min_dist_samp = int(min_dist_sec * sr)
+        prominence = v90 * 0.30
 
         peaks, props = scipy.signal.find_peaks(
             coarse_env,
@@ -160,7 +152,7 @@ def calculate_bpm(y, sr):
             prominence=prominence,
         )
 
-        # ── 5. Fallback for Quiet / Far Recordings ────────────────────────────
+        # Fallback for quiet recordings
         if len(peaks) < 2:
             peaks, _ = scipy.signal.find_peaks(
                 coarse_env,
@@ -170,38 +162,63 @@ def calculate_bpm(y, sr):
             if len(peaks) < 2:
                 return 0, 0, np.array([])
 
-        # ── 6. Adaptive S2 Rejection ──────────────────────────────────────────
-        # Instead of a fixed refractory window, use the MEDIAN interval to
-        # adaptively reject S2 peaks. S2 is typically 60-70% of the cycle
-        # length after S1. Any peak within 40% of the median interval is
-        # likely S2 and should be removed.
-        if len(peaks) >= 3:
-            intervals = np.diff(peaks)
-            med_interval = np.median(intervals)
-            # Refractory = 40% of median interval (NOT a fixed 400-500ms)
-            # At 60 BPM: med=44100, refractory=17640 (400ms) — same as before
-            # At 180 BPM: med=14700, refractory=5880 (133ms) — catches fast beats
-            refractory = int(med_interval * 0.40)
-            refractory = max(refractory, int(0.12 * sr))  # floor: 120ms (absolute minimum)
-
-            clean_peaks = [peaks[0]]
-            for pk in peaks[1:]:
-                if pk - clean_peaks[-1] >= refractory:
-                    clean_peaks.append(pk)
-            peaks = np.array(clean_peaks)
+        # Post-detection refractory check
+        refractory = int(0.40 * sr)
+        clean_peaks = [peaks[0]]
+        for pk in peaks[1:]:
+            if pk - clean_peaks[-1] >= refractory:
+                clean_peaks.append(pk)
 
+        peaks = np.array(clean_peaks)
         if len(peaks) < 2:
             return 0, 0, peaks
 
-        # ── 7. BPM Calculation ────────────────────────────────────────────────
-        # Use median of inter-beat intervals (robust to occasional missed beats)
+        # Peak-based BPM
         intervals = np.diff(peaks)
         median_interval = np.median(intervals)
-        bpm = (60.0 * sr) / median_interval
+        peak_bpm = (60.0 * sr) / median_interval
+
+        # ── 5. Autocorrelation BPM (robust at all heart rates) ────────────────
+        # Autocorrelation finds the dominant periodicity in the envelope.
+        # The full cardiac cycle (S1+S2+pause) repeats, so the autocorrelation
+        # peak corresponds to the S1-to-S1 interval — regardless of heart rate.
+        acorr_bpm = 0
+        try:
+            # Normalize envelope for autocorrelation
+            env_norm = coarse_env - np.mean(coarse_env)
+            autocorr = np.correlate(env_norm, env_norm, mode='full')
+            autocorr = autocorr[len(autocorr) // 2:]  # keep positive lags only
+            autocorr = autocorr / autocorr[0]  # normalize
+
+            # Search for dominant peak in physiological range:
+            # 40 BPM → 1.5s period, 250 BPM → 0.24s period
+            min_lag = int(0.24 * sr)   # 250 BPM
+            max_lag = int(1.5 * sr)    # 40 BPM
+
+            if max_lag <= len(autocorr):
+                search_region = autocorr[min_lag:max_lag]
+                if len(search_region) > 0:
+                    acorr_peaks, _ = scipy.signal.find_peaks(search_region, prominence=0.1)
+                    if len(acorr_peaks) > 0:
+                        # First prominent peak = fundamental cardiac cycle period
+                        best_lag = acorr_peaks[0] + min_lag
+                        acorr_bpm = (60.0 * sr) / best_lag
+        except Exception:
+            pass
+
+        # ── 6. Choose best BPM estimate ───────────────────────────────────────
+        # Peak detection is reliable for normal rates but caps at ~120 BPM.
+        # Autocorrelation works at all rates. Use autocorrelation when it
+        # detects a meaningfully faster rate (suggesting tachycardia that
+        # peak detection is missing).
+        if acorr_bpm > 0 and acorr_bpm > peak_bpm * 1.3:
+            # Autocorrelation found significantly faster rate → tachycardia
+            bpm = acorr_bpm
+        else:
+            bpm = peak_bpm
 
-        # Clamp to physiological canine range (40–300 BPM)
-        # Small breeds and SVT can reach 240+ BPM
-        bpm = int(max(40, min(300, bpm)))
+        # Clamp to physiological canine range (40–250 BPM)
+        bpm = int(max(40, min(250, bpm)))
         return bpm, len(peaks), peaks
 
     except Exception as e: