feat: CNN per-segment breakdown (segments field in predict_cnn)

inference.py

@@ -716,33 +716,97 @@ def _load_gru_model():
 
 
 def predict_gru(y, sr):
-    """Classify using Bi-GRU with log-spectrogram (McDonald et al., 2024)."""
+    """
+    Classify using Bi-GRU with log-spectrogram (McDonald et al., 2024).
+
+    Uses 5-second windows with 2.5-second stride (50% overlap), matching the
+    AryanGit720 reference implementation for clinical segment-level analysis.
+    Windows: 0-5s, 2.5-7.5s, 5-10s, 7.5-12.5s, ...
+    """
     if not _load_gru_model():
         return None
     import torch
-    # Resample to 4kHz for GRU
+
+    # Resample to 4 kHz (GRU training SR)
     y_4k = librosa.resample(y, orig_sr=sr, target_sr=GRU_SR)
-    N_FFT_G, HOP_G, CLIP_SEC = 256, 64, 5
-    target_len = GRU_SR * CLIP_SEC
-    clips = [y_4k[s:s+target_len] for s in range(0, len(y_4k)-target_len+1, target_len)] if len(y_4k) >= target_len else [np.pad(y_4k, (0, target_len-len(y_4k)))]
+
+    N_FFT_G  = 256
+    HOP_G    = 64
+    CLIP_SEC = 5
+    STEP_SEC = 2.5          # 50% overlap stride
+
+    target_len = int(GRU_SR * CLIP_SEC)   # 20 000 samples @ 4 kHz
+    step_len   = int(GRU_SR * STEP_SEC)   # 10 000 samples
+
     GRU_BINARY_NAMES = ["Normal", "Murmur"]
-    probs = []
-    for clip in clips:
-        S = np.abs(librosa.stft(clip, n_fft=N_FFT_G, hop_length=HOP_G)) ** 2
+    MURMUR_THRESHOLD = 0.50   # standard 50/50 threshold for binary GRU
+
+    # ── Build overlapping windows ──────────────────────────────────────────
+    starts = []
+    if len(y_4k) >= target_len:
+        s = 0
+        while s + target_len <= len(y_4k):
+            starts.append(s)
+            s += step_len
+    else:
+        starts = [0]   # short recording: single padded clip
+
+    probs      = []   # (N_windows, 2)
+    raw_starts = []   # sample start in y_4k for each window
+
+    for s in starts:
+        clip = y_4k[s: s + target_len]
+        if len(clip) < target_len:
+            clip = np.pad(clip, (0, target_len - len(clip)))
+
+        S     = np.abs(librosa.stft(clip, n_fft=N_FFT_G, hop_length=HOP_G)) ** 2
         log_S = np.log1p(S)
         log_S = (log_S - log_S.mean()) / (log_S.std() + 1e-8)
-        spec = log_S.T.astype(np.float32)  # (time, freq) for GRU
+        spec  = log_S.T.astype(np.float32)   # (time_frames, freq_bins)
+
         t = torch.FloatTensor(spec).unsqueeze(0)
         with torch.no_grad():
-            probs.append(torch.softmax(_gru_model(t), 1)[0].numpy())
-    avg = np.mean(probs, 0)
+            p = torch.softmax(_gru_model(t), 1)[0].numpy()
+        probs.append(p)
+        raw_starts.append(s)
+
+    # ── Per-segment results (for timeline + table in UI) ──────────────────
+    segments = []
+    for i, (p, s_samp) in enumerate(zip(probs, raw_starts)):
+        murmur_p   = float(p[1])
+        is_seg_mur = murmur_p >= MURMUR_THRESHOLD
+        start_sec  = round(s_samp / GRU_SR, 2)
+        end_sec    = round((s_samp + target_len) / GRU_SR, 2)
+        segments.append({
+            "segment_idx": i,
+            "start_sec":   start_sec,
+            "end_sec":     end_sec,
+            "top_label":   "Murmur" if is_seg_mur else "Normal",
+            "is_murmur":   is_seg_mur,
+            "murmur_prob": round(murmur_p, 4),
+            "probs": {
+                "Normal": round(float(p[0]), 4),
+                "Murmur": round(murmur_p, 4),
+            },
+        })
+
+    # ── Record-level aggregate (average across all windows) ───────────────
+    avg  = np.mean(probs, axis=0)
     pred = int(np.argmax(avg))
-    is_murmur = pred == 1
-    label = GRU_BINARY_NAMES[pred]
+    is_murmur = bool(avg[1] >= MURMUR_THRESHOLD)
+    label = "Murmur" if is_murmur else "Normal"
+
     return {
-        "label": label, "confidence": round(float(avg[pred]), 4),
-        "is_disease": is_murmur, "method": "Bi-GRU Binary (McDonald et al., Cambridge 2024)",
-        "all_classes": [{"label": GRU_BINARY_NAMES[i], "probability": round(float(avg[i]), 4)} for i in range(2)],
+        "label":      label,
+        "confidence": round(float(avg[1] if is_murmur else avg[0]), 4),
+        "is_disease": is_murmur,
+        "method":     "Bi-GRU Binary (McDonald et al., Cambridge 2024)",
+        "clips_analyzed": len(probs),
+        "segments":   segments,   # per-2.5s-step window breakdown for UI
+        "all_classes": [
+            {"label": GRU_BINARY_NAMES[i], "probability": round(float(avg[i]), 4)}
+            for i in range(2)
+        ],
     }