SONICS detect API (FastAPI wrapper, SpecTTTra-alpha-120s)

app.py

@@ -9,6 +9,7 @@ from fastapi import FastAPI, File, Header, HTTPException, UploadFile
 MODEL_ID = os.environ.get("MODEL_ID", "awsaf49/sonics-spectttra-alpha-120s")
 API_KEY = os.environ.get("DETECT_API_KEY", "")
 MAX_BYTES = 25 * 1024 * 1024
+MODEL_SR = 16000
 
 torch.set_num_threads(2)
 
@@ -31,6 +32,58 @@ def health():
     return {"ok": True, "model": MODEL_ID, "loaded": model is not None}
 
 
+def compute_signals(y: np.ndarray, sr: int) -> dict:
+    """Audio-forensic descriptors computed at the file's native sample rate."""
+    out: dict = {"native_sample_rate": int(sr)}
+    try:
+        S = np.abs(librosa.stft(y, n_fft=2048, hop_length=512))
+        freqs = librosa.fft_frequencies(sr=sr, n_fft=2048)
+        mag = S.mean(axis=1)
+        power = mag**2
+        total = float(power.sum()) or 1e-12
+
+        # Spectral cutoff: frequency below which 99% of energy lives.
+        cum = np.cumsum(power)
+        idx = int(np.searchsorted(cum, 0.99 * cum[-1]))
+        out["spectral_cutoff_hz"] = int(freqs[min(idx, len(freqs) - 1)])
+
+        # Share of energy above 10 kHz (only meaningful when sr allows it).
+        if sr >= 32000:
+            out["hf_energy_ratio"] = round(float(power[freqs >= 10000].sum() / total), 5)
+        else:
+            out["hf_energy_ratio"] = None
+
+        # Dynamic range: dB spread between loud and quiet frames.
+        rms = librosa.feature.rms(y=y, hop_length=512)[0]
+        rms = rms[rms > 1e-6]
+        if rms.size:
+            out["dynamic_range_db"] = round(
+                float(20 * np.log10(np.percentile(rms, 95) / max(np.percentile(rms, 10), 1e-9))), 1
+            )
+        else:
+            out["dynamic_range_db"] = None
+
+        # Spectral flatness: noisiness/synthetic-ness of the average spectrum.
+        out["spectral_flatness"] = round(float(librosa.feature.spectral_flatness(y=y).mean()), 4)
+
+        # Tempo and beat regularity (coefficient of variation of inter-beat intervals).
+        try:
+            tempo, beats = librosa.beat.beat_track(y=y, sr=sr, hop_length=512)
+            tempo_val = float(np.atleast_1d(tempo)[0]) if tempo is not None else 0.0
+            out["tempo_bpm"] = round(tempo_val, 1) if tempo_val > 0 else None
+            if beats is not None and len(beats) > 8:
+                ibis = np.diff(librosa.frames_to_time(beats, sr=sr, hop_length=512))
+                out["tempo_cv"] = round(float(np.std(ibis) / max(np.mean(ibis), 1e-9)), 4)
+            else:
+                out["tempo_cv"] = None
+        except Exception:
+            out["tempo_bpm"] = None
+            out["tempo_cv"] = None
+    except Exception:
+        pass
+    return out
+
+
 @app.post("/detect")
 def detect(audio: UploadFile = File(...), x_detect_key: str = Header(default="")):
     if API_KEY and x_detect_key != API_KEY:
@@ -50,18 +103,26 @@ def detect(audio: UploadFile = File(...), x_detect_key: str = Header(default="")
             tmp.write(data)
             tmp_path = tmp.name
         try:
-            y, sr = librosa.load(tmp_path, sr=16000, mono=True)
+            # Native rate for forensic signals (high-frequency artifacts live here).
+            y_native, sr_native = librosa.load(tmp_path, sr=None, mono=True)
         finally:
             os.unlink(tmp_path)
     except Exception:
         raise HTTPException(status_code=400, detail="Could not decode audio")
 
-    if y.size < sr * 3:
+    if y_native.size < sr_native * 3:
         raise HTTPException(status_code=400, detail="Audio too short (min 3s)")
 
-    # Same chunking as the official SONICS demo: score the middle max_time window.
+    signals = compute_signals(y_native, sr_native)
+
+    # Model expects 16 kHz; score the middle max_time window (official demo logic).
+    y = (
+        librosa.resample(y_native, orig_sr=sr_native, target_sr=MODEL_SR)
+        if sr_native != MODEL_SR
+        else y_native
+    )
     max_time = model.config.audio.max_time
-    chunk_samples = int(max_time * sr)
+    chunk_samples = int(max_time * MODEL_SR)
     total_chunks = len(y) // chunk_samples
     middle_idx = total_chunks // 2
     start = middle_idx * chunk_samples
@@ -75,6 +136,7 @@ def detect(audio: UploadFile = File(...), x_detect_key: str = Header(default="")
 
     return {
         "ai_prob": round(ai_prob, 4),
-        "duration_s": round(len(y) / sr, 1),
+        "duration_s": round(len(y_native) / sr_native, 1),
         "model": MODEL_ID,
+        "signals": signals,
     }