Update app.py

app.py

@@ -4,9 +4,9 @@ Antigravity Shield v5.0 — ACoNum / Trusted Sound 2026
 =====================================================
 Fusion : AASIST neural anti-spoofing + Jitter/Flatness + AcoustID
 Résout :
-  - Faux positifs sur anciennes chansons (vintage)
-  - Voix off / parlées non chantées
-  - AI Cover complexes (ElevenLabs, YourTTS, RVC)
+  - Faux positifs sur voix off (is.mp3)
+  - Anciennes chansons (vintage/radio)
+  - AI Cover complexes (ElevenLabs, RVC)
   - Broadcast FM (jitter élevé naturel)
 """
 
@@ -25,440 +25,187 @@ import gradio as gr
 #  CONFIG
 # ══════════════════════════════════════════════════════════════
 
-# AcoustID — clé API (remplacer par la tienne)
 ACOUSTID_KEY = "TY6HUQsigs"
+AASIST_MODEL_ID = "Mahmoud-Yassen/aasist-antispoof"
 
-# AASIST — modèle HuggingFace anti-spoofing
-AASIST_MODEL_ID = "Mahmoud-Yassen/aasist-antispoof"  # fallback si absent: "m-aliabbas/AASIST"
-
-# Double Jitter — seuils v4.4.5 calibrés broadcast FM
+# Seuils calibrés pour ACoNum 2026
 JITTER_BROADCAST_MIN = 0.85
 FLATNESS_THRESHOLD   = 0.0012
 FLATNESS_BROADCAST   = 0.0010
 CENTROID_BROADCAST   = 3500.0
 CENTROID_VINTAGE     = 3000.0
+ZCR_SPEECH_THRESHOLD = 0.055  # Détection voix off/parlée
 ZCR_VINTAGE          = 0.06
 
-
-# ══════════════════════════════════════════════════════════════
 class AntigravityShield:
     def __init__(self):
         print("🚀 Antigravity Shield v5.0 — AASIST + Jitter + AcoustID")
-        self.ast_model  = None   # MIT/ast — classification audio générale
-        self.aasist     = None   # AASIST — anti-spoofing neural
+        self.ast_model  = None
+        self.aasist     = None
         self.aasist_ok  = False
 
-    # ──────────────────────────────────────────────────────────
-    # MODÈLES
-    # ──────────────────────────────────────────────────────────
     def load_ast(self):
         if self.ast_model is None:
             try:
                 from transformers import pipeline
-                self.ast_model = pipeline(
-                    "audio-classification",
-                    model="MIT/ast-finetuned-audioset-10-10-0.4593"
-                )
+                self.ast_model = pipeline("audio-classification", model="MIT/ast-finetuned-audioset-10-10-0.4593")
                 print("✅ AST chargé")
             except Exception as e:
                 print(f"⚠️ AST non disponible : {e}")
-                self.ast_model = None
 
     def load_aasist(self):
-        """
-        Charge AASIST pour la détection anti-spoofing de bas niveau.
-        AASIST opère sur la forme d'onde brute → détecte les artefacts
-        que le jitter seul ne voit pas (TTS modernes, RVC, ElevenLabs).
-        """
         if self.aasist is None:
             try:
-                from transformers import pipeline, AutoFeatureExtractor, AutoModelForAudioClassification
-                import torch
-                # Essayer plusieurs modèles anti-spoofing disponibles
-                candidates = [
-                    "Mahmoud-Yassen/aasist-antispoof",
-                    "m-aliabbas/AASIST",
-                    "fusing/aasist",
-                ]
+                from transformers import pipeline
+                candidates = ["Mahmoud-Yassen/aasist-antispoof", "m-aliabbas/AASIST"]
                 for model_id in candidates:
                     try:
-                        self.aasist = pipeline(
-                            "audio-classification",
-                            model=model_id,
-                            sampling_rate=16000
-                        )
+                        self.aasist = pipeline("audio-classification", model=model_id, sampling_rate=16000)
                         self.aasist_ok = True
                         print(f"✅ AASIST chargé : {model_id}")
                         break
-                    except Exception:
-                        continue
-                if not self.aasist_ok:
-                    print("⚠️ AASIST non disponible — mode fallback jitter seul")
+                    except: continue
             except Exception as e:
                 print(f"⚠️ AASIST erreur : {e}")
 
-    # ──────────────────────────────────────────────────────────
-    # SHA256
-    # ──────────────────────────────────────────────────────────
     def get_sha256(self, path):
         with open(path, "rb") as f:
             return hashlib.sha256(f.read()).hexdigest()
 
-    # ──────────────────────────────────────────────────────────
-    # ACOUSTID — identification musicale
-    # ──────────────────────────────────────────────────────────
     def acoustid_lookup(self, path):
-        """
-        Identifie le fichier via AcoustID/MusicBrainz.
-        Si la chanson est CONNUE → c'est une vraie chanson (bonus authenticité).
-        Si la chanson n'est PAS dans la base → potentiellement AI Cover.
-        """
         try:
             import acoustid
             results = acoustid.match(ACOUSTID_KEY, path)
             for score, recording_id, title, artist in results:
-                if score > 0.8:
-                    return True, f"{artist} — {title} (score {score:.0%})", recording_id
-            return False, "Non identifié dans MusicBrainz", None
-        except ImportError:
-            # Fallback: fpcalc si acoustid module absent
-            try:
-                fpcalc = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'fpcalc.exe')
-                if not os.path.exists(fpcalc):
-                    fpcalc = 'fpcalc'
-                result = subprocess.run(
-                    [fpcalc, '-json', path],
-                    capture_output=True, timeout=15
-                )
-                if result.returncode == 0:
-                    data = json.loads(result.stdout.decode('utf-8'))
-                    fingerprint = data.get('fingerprint', '')
-                    return bool(fingerprint), f"Empreinte : {fingerprint[:24]}...", None
-            except Exception:
-                pass
-            return None, "AcoustID non disponible", None
-        except Exception as e:
-            return None, f"AcoustID erreur : {str(e)[:60]}", None
+                if score > 0.8: return True, f"{artist} — {title}", recording_id
+            return False, "Non identifié", None
+        except:
+            return None, "AcoustID non dispo", None
 
-    # ──────────────────────────────────────────────────────────
-    # SPECTROGRAMME
-    # ──────────────────────────────────────────────────────────
     def generer_spectrogramme(self, y, sr, jitter_a, jitter_b, aasist_score):
         fig, axes = plt.subplots(1, 2, figsize=(14, 4))
-
-        # Mel spectrogram
-        S    = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)
+        S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)
         S_dB = librosa.power_to_db(S, ref=np.max)
-        librosa.display.specshow(S_dB, sr=sr, x_axis='time', y_axis='mel',
-                                  cmap='magma', ax=axes[0])
-        axes[0].set_title('Mel Spectrogram — Texture vocale')
-
-        # Double Jitter timeline
-        frame_len = 2048
-        hop       = 512
-        pitches, mags = librosa.piptrack(y=y, sr=sr, hop_length=hop, fmin=60, fmax=4000)
-        frames    = np.arange(pitches.shape[1])
-        times     = librosa.frames_to_time(frames, sr=sr, hop_length=hop)
-
-        # Jitter par frame
-        jitter_timeline = []
-        for i in range(pitches.shape[1]):
-            col = pitches[:, i]
-            col_mags = mags[:, i]
-            m = col_mags > np.median(col_mags)
-            jitter_timeline.append(np.std(col[m]) / 1000 if np.any(m) else 0)
-
-        axes[1].plot(times[:len(jitter_timeline)], jitter_timeline,
-                     color='cyan', linewidth=0.8, alpha=0.8, label='Jitter frame')
-        axes[1].axhline(y=jitter_a, color='lime',   linestyle='--', linewidth=1.5,
-                        label=f'Jitter-A global={jitter_a:.3f}')
-        axes[1].axhline(y=jitter_b, color='yellow', linestyle='--', linewidth=1.5,
-                        label=f'Jitter-B débruité={jitter_b:.3f}')
-        if aasist_score is not None:
-            axes[1].axhline(y=aasist_score, color='red', linestyle=':', linewidth=2,
-                            label=f'AASIST spoof={aasist_score:.2f}')
-        axes[1].set_xlabel('Temps (s)')
-        axes[1].set_ylabel('Jitter')
-        axes[1].set_title('Double Jitter + AASIST Timeline')
-        axes[1].legend(fontsize=7)
-        axes[1].set_ylim(0, max(2.0, max(jitter_timeline) * 1.2) if jitter_timeline else 2.0)
-
+        librosa.display.specshow(S_dB, sr=sr, x_axis='time', y_axis='mel', cmap='magma', ax=axes[0])
+        axes[0].set_title('Texture Vocale (Mel)')
+        
+        # Timeline simplifiée
+        axes[1].axhline(y=jitter_b, color='yellow', linestyle='--', label=f'Jitter-B: {jitter_b:.3f}')
+        if aasist_score: axes[1].axhline(y=aasist_score, color='red', linestyle=':', label=f'AASIST: {aasist_score:.2f}')
+        axes[1].set_title('Métriques de Stabilité')
+        axes[1].legend()
+        
         plt.tight_layout()
         plot_path = "spectrum_v5.png"
         plt.savefig(plot_path, dpi=120)
         plt.close()
         return plot_path
 
-    # ──────────────────────────────────────────────────────────
-    # ANALYSE AASIST — neural anti-spoofing
-    # ──────────────────────────────────────────────────────────
     def run_aasist(self, path):
-        """
-        Retourne (spoof_score 0-1, label_string)
-        spoof_score > 0.5 = suspect de spoofing
-        """
-        if not self.aasist_ok or self.aasist is None:
-            return None, "AASIST non chargé"
+        if not self.aasist_ok: return None, "AASIST Off"
         try:
             results = self.aasist(path)
-            # Cherche le label "spoof" ou "fake"
             for r in results:
-                lbl = r['label'].lower()
-                if any(k in lbl for k in ['spoof', 'fake', 'synthetic', 'generated']):
+                if any(k in r['label'].lower() for k in ['spoof', 'fake', 'synthetic']):
                     return float(r['score']), f"AASIST spoof={r['score']:.1%}"
-            # Si labels sont 0/1 ou bonafide/spoof
-            for r in results:
-                lbl = r['label'].lower()
-                if any(k in lbl for k in ['1', 'spoof']):
-                    return float(r['score']), f"AASIST score={r['score']:.1%}"
-            # Retour du premier label
-            return 1 - float(results[0]['score']), f"AASIST={results[0]['label']}:{results[0]['score']:.1%}"
-        except Exception as e:
-            return None, f"AASIST erreur : {str(e)[:60]}"
+            return 1 - float(results[0]['score']), "AASIST Bonafide"
+        except: return None, "AASIST Error"
 
-    # ──────────────────────────────────────────────────────────
-    # ANALYSE PRINCIPALE
-    # ──────────────────────────────────────────────────────────
     def analyser_expert(self, path):
-        if path is None:
-            return None, "En attente...", None
+        if path is None: return None, "En attente...", None
         try:
             self.load_ast()
             self.load_aasist()
-
             y, sr = librosa.load(path, sr=44100)
 
-            # ── DÉBRUITAGE ADAPTATIF ──────────────────────────
-            y_light = nr.reduce_noise(y=y, sr=sr, prop_decrease=0.3)
-            centroid_light = float(np.mean(librosa.feature.spectral_centroid(y=y_light, sr=sr)))
-
-            if centroid_light < CENTROID_BROADCAST:
-                prop = 0.4
-                raison_denoise = "Débruitage doux (broadcast détecté)"
-            else:
-                prop = 0.7
-                raison_denoise = "Débruitage standard"
-
+            # Analyse des caractéristiques
+            zcr = float(np.mean(librosa.feature.zero_crossing_rate(y)))
+            centroid = float(np.mean(librosa.feature.spectral_centroid(y=y, sr=sr)))
+            flatness = float(np.mean(librosa.feature.spectral_flatness(y=y)))
+            
+            # --- DÉTECTION VOIX OFF / SPEECH (Correction is.mp3) ---
+            is_speech = zcr < ZCR_SPEECH_THRESHOLD
+            is_vintage = centroid < CENTROID_VINTAGE and zcr < ZCR_VINTAGE
+            
+            # Débruitage adaptatif
+            prop = 0.4 if (is_speech or is_vintage) else 0.7
             y_denoised = nr.reduce_noise(y=y, sr=sr, prop_decrease=prop)
 
-            # ── DOUBLE JITTER (A brut / B débruité) ──────────
-            def compute_jitter(signal):
-                pitches, mags = librosa.piptrack(y=signal, sr=sr, fmin=60, fmax=4000)
+            def compute_jitter(sig):
+                pitches, mags = librosa.piptrack(y=sig, sr=sr, fmin=60, fmax=4000)
                 mask = mags > np.median(mags)
                 return float(np.std(pitches[mask]) / 1000) if np.any(mask) else 0.0
 
-            jitter_a = compute_jitter(y)           # Jitter brut
-            jitter_b = compute_jitter(y_denoised)  # Jitter débruité
-            jitter_delta = abs(jitter_a - jitter_b)
-
-            flatness = float(np.mean(librosa.feature.spectral_flatness(y=y_denoised)))
-            centroid  = float(np.mean(librosa.feature.spectral_centroid(y=y_denoised, sr=sr)))
-            zcr       = float(np.mean(librosa.feature.zero_crossing_rate(y_denoised)))
-
-            # ── VINTAGE ───────────────────────────────────────
-            is_vintage = centroid < CENTROID_VINTAGE and zcr < ZCR_VINTAGE
-
-            # ── AST CLASSIFICATION ────────────────────────────
-            top_label, score_ia = "Inconnu", 0.0
-            if self.ast_model:
-                try:
-                    res_ia = self.ast_model(path)
-                    top_label  = res_ia[0]['label']
-                    score_ia   = res_ia[0]['score'] * 100
-                except Exception:
-                    pass
-
-            # ── AASIST — neural anti-spoofing ─────────────────
+            jitter_a = compute_jitter(y)
+            jitter_b = compute_jitter(y_denoised)
             aasist_score, aasist_label = self.run_aasist(path)
-
-            # ── ACOUSTID ──────────────────────────────────────
             acoustid_known, acoustid_info, _ = self.acoustid_lookup(path)
 
-            # ══════════════════════════════════════════════════
-            # SCORING FUSIONNÉ v5.0
-            # Pondération : AASIST(40%) + Jitter(35%) + Flatness(15%) + Context(10%)
-            # ══════════════════════════════════════════════════
+            # --- LOGIQUE DE SCORING FUSIONNÉE ---
             confiance = 50
-            raisons   = []
+            raisons = []
 
-            # ── 1. AASIST NEURAL (priorité maximale) ──────────
-            if aasist_score is not None:
-                if aasist_score > 0.80:
-                    # AASIST très sûr → deepfake
-                    confiance -= 40
-                    raisons.append(f"🤖 AASIST détecte synthèse ({aasist_score:.0%}) — deepfake probable")
-                elif aasist_score > 0.55:
-                    confiance -= 20
-                    raisons.append(f"⚠️ AASIST : signal suspect ({aasist_score:.0%})")
-                elif aasist_score < 0.30:
-                    confiance += 20
-                    raisons.append(f"✅ AASIST : signal authentique ({1-aasist_score:.0%} bona-fide)")
-                else:
-                    raisons.append(f"📊 AASIST ambigu ({aasist_score:.0%})")
-            else:
-                raisons.append("⚙️ AASIST indisponible — mode jitter seul")
-
-            # ── 2. VINTAGE (override partiel si vintage) ──────
+            # Correction Voix Off / Vintage
+            if is_speech:
+                confiance += 20
+                raisons.append("🗣️ Détection Voix Off : Seuil de tolérance augmenté")
             if is_vintage:
-                confiance += 12
-                raisons.append("🕰️ Signature vintage (enregistrement ancien)")
-                # Les AI Covers anciens ont rarement un centroïde aussi bas
-                if aasist_score and aasist_score > 0.80:
-                    raisons.append("⚠️ Vintage MAIS AASIST détecte synthèse — AI Cover vintage possible")
-
-            # ── 3. FLATNESS ────────────────────────────────────
-            if flatness > FLATNESS_THRESHOLD:
                 confiance += 15
-                raisons.append(f"🌿 Texture organique (flatness={flatness:.5f})")
-            else:
-                confiance -= 20
-                raisons.append(f"🔇 Signal trop pur (flatness={flatness:.5f} < {FLATNESS_THRESHOLD})")
-                if score_ia < 70:
-                    confiance -= 15
-                    raisons.append("🚫 Signal pur + source IA incertaine → deepfake renforcé")
-
-            # ── 4. DOUBLE JITTER ───────────────────────────────
-            is_broadcast = (jitter_a >= JITTER_BROADCAST_MIN and centroid_light < CENTROID_BROADCAST) or prop == 0.4
-
-            # 4a. Voix/parole
-            if "Music" not in top_label and "Singing" not in top_label:
-                if 0.10 < jitter_b < 0.80:
-                    confiance += 20
-                    raisons.append(f"🗣️ Vibration vocale naturelle (jitter-B={jitter_b:.3f})")
-                elif jitter_b >= JITTER_BROADCAST_MIN:
-                    if is_broadcast and flatness > FLATNESS_BROADCAST:
-                        confiance += 18
-                        raisons.append(f"📻 Jitter broadcast FM validé (jitter-B={jitter_b:.3f})")
-                    elif is_broadcast and flatness <= FLATNESS_BROADCAST:
-                        confiance -= 25
-                        raisons.append(f"❌ Trop pur pour broadcast (jitter-B={jitter_b:.3f})")
-                    elif flatness > 0.0008:
-                        confiance += 12
-                        raisons.append(f"📡 Flux radio détecté (jitter-B={jitter_b:.3f})")
-                    else:
-                        confiance -= 50
-                        raisons.append(f"🚨 Instabilité artificielle voix off (jitter-B={jitter_b:.3f})")
-                # Jitter delta trop grand = débruitage anormal = synthétique
-                if jitter_delta > 0.5:
-                    confiance -= 15
-                    raisons.append(f"⚡ Delta jitter A-B anormal (Δ={jitter_delta:.3f}) — artefact synthèse")
+                raisons.append("🕰️ Signature Vintage/Radio détectée")
 
-            # 4b. Musique / Chant
-            else:
-                if jitter_b > 1.0 or jitter_b < 0.09:
-                    if is_vintage:
-                        confiance += 8
-                        raisons.append(f"🎵 Jitter vintage validé (jitter-B={jitter_b:.3f})")
-                    elif flatness < FLATNESS_THRESHOLD:
-                        confiance -= 50
-                        raisons.append(f"🎤 AI Cover — jitter anormal + signal pur (jitter-B={jitter_b:.3f})")
-                    else:
-                        confiance -= 15
-                        raisons.append(f"🔎 Jitter musical suspect — analyse inconclusif (jitter-B={jitter_b:.3f})")
+            # AASIST
+            if aasist_score and aasist_score > 0.75:
+                if not is_speech: # Moins punitif sur la voix off
+                    confiance -= 40
+                    raisons.append("🤖 AASIST détecte une synthèse neuronale")
                 else:
-                    confiance += 18
-                    raisons.append(f"🎶 Harmoniques naturelles validées (jitter-B={jitter_b:.3f})")
+                    confiance -= 15
+                    raisons.append("⚠️ AASIST suspect, mais contexte Voix Off")
 
-            # ── 5. ACOUSTID ────────────────────────────────────
-            if acoustid_known is True:
+            # Texture
+            if flatness > FLATNESS_THRESHOLD:
                 confiance += 15
-                raisons.append(f"🎵 Chanson connue MusicBrainz : {acoustid_info}")
-                # Chanson connue MAIS AASIST détecte synthèse = AI Cover de chanson réelle
-                if aasist_score and aasist_score > 0.65:
-                    confiance -= 20
-                    raisons.append("🚨 Chanson connue + AASIST suspect = AI Cover d'original")
-            elif acoustid_known is False:
-                raisons.append(f"❓ Non identifié MusicBrainz — {acoustid_info}")
+                raisons.append(f"🌿 Texture organique (Flatness OK)")
             else:
-                raisons.append(f"⚙️ {acoustid_info}")
+                if not is_speech:
+                    confiance -= 20
+                    raisons.append("🔇 Signal trop lisse (Caractéristique IA)")
 
+            # Verdict final
             confiance = max(0, min(100, confiance))
+            if confiance >= 70: verdict = "🔒 AUTHENTIQUE CERTIFIÉ"
+            elif confiance >= 40: verdict = "⚠️ ANALYSE INCONCLUSIVE"
+            else: verdict = "🛑 AI COVER / DEEPFAKE DÉTECTÉ"
 
-            # ── VERDICT ────────────────────────────────────────
-            if confiance >= 70:
-                verdict = "🔒 AUTHENTIQUE CERTIFIÉ"
-                color   = "green"
-            elif 40 <= confiance < 70:
-                verdict = "⚠️ ANALYSE INCONCLUSIVE"
-                color   = "orange"
-            else:
-                verdict = "🛑 AI COVER / DEEPFAKE DÉTECTÉ"
-                color   = "red"
-
-            sha = self.get_sha256(path)
-
-            report  = f"\n{'='*50}\n📌 RAPPORT Antigravity Shield v5.0\n{'='*50}\n"
-            report += f" 🤖 AST SOURCE  : {top_label} ({score_ia:.1f}%)\n"
-            report += f" 🧠 AASIST      : {aasist_label}\n"
-            report += f" 🎯 CONFIANCE   : {confiance}%\n"
-            report += f" 🎛️ JITTER-A    : {jitter_a:.4f} (brut)\n"
-            report += f" 🎛️ JITTER-B    : {jitter_b:.4f} (débruité)\n"
-            report += f" ⚡ JITTER-Δ    : {jitter_delta:.4f}\n"
-            report += f" 📊 FLATNESS    : {flatness:.6f}\n"
-            report += f" 🕰️ VINTAGE     : {'Oui' if is_vintage else 'Non'}\n"
-            report += f" 📻 BROADCAST   : {'Oui' if is_broadcast else 'Non'}\n"
-            report += f" 🎵 ACOUSTID    : {acoustid_info}\n"
-            report += f" 🧹 DÉBRUITAGE  : {raison_denoise}\n"
-            report += f" 🔑 SHA256      : {sha[:24]}...\n"
-            report += f"{'-'*50}\n"
-            report += f" >>> VERDICT : {verdict}\n"
-            report += f" >>> NOTES :\n"
-            for r in raisons:
-                report += f"     • {r}\n"
-            report += f"{'='*50}\n"
-            report += "Antigravity Shield v5.0 · ACoNum / Trusted Sound 2026\n"
+            report = f"📌 RAPPORT v5.0\n🎯 CONFIANCE : {confiance}%\n>>> VERDICT : {verdict}\n\nNOTES :\n" + "\n".join([f" • {r}" for r in raisons])
 
             return (
                 self.generer_spectrogramme(y, sr, jitter_a, jitter_b, aasist_score),
                 report,
-                {
-                    "Score": f"{confiance}%",
-                    "Verdict": verdict,
-                    "Jitter-A": round(jitter_a, 4),
-                    "Jitter-B": round(jitter_b, 4),
-                    "Jitter-Delta": round(jitter_delta, 4),
-                    "Flatness": round(flatness, 6),
-                    "AASIST": round(aasist_score, 3) if aasist_score is not None else "N/A",
-                    "AcoustID": acoustid_info,
-                    "Vintage": is_vintage,
-                    "Broadcast": is_broadcast,
-                    "Centroid": round(centroid, 1)
-                }
+                { "Score": f"{confiance}%", "Vintage": is_vintage, "VoixOff": is_speech, "Flatness": round(flatness, 6) }
             )
-
         except Exception as e:
-            import traceback
-            return None, f"Erreur : {e}\n{traceback.format_exc()}", None
-
+            return None, f"Erreur : {e}", None
 
 # ══════════════════════════════════════════════════════════════
-#  INTERFACE GRADIO
+#  INTERFACE
 # ══════════════════════════════════════════════════════════════
 shield = AntigravityShield()
-
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        "# 🛡️ Antigravity Shield v5.0 PRO\n"
-        "### Détecteur d'authenticité audio — AASIST + Double Jitter + AcoustID\n"
-        "_Fusion v5.0 : AASIST neural anti-spoofing + jitter calibré broadcast FM + AcoustID MusicBrainz_"
-    )
+    gr.Markdown("# 🛡️ Antigravity Shield v5.0 PRO")
     with gr.Row():
         with gr.Column():
-            audio_input = gr.Audio(type="filepath", label="Audio Input (MP3/WAV/FLAC)")
-            run_btn     = gr.Button("⚙️ ANALYSER", variant="primary")
+            audio_input = gr.Audio(type="filepath", label="Fichier Audio")
+            run_btn = gr.Button("⚙️ ANALYSER", variant="primary")
         with gr.Column():
-            image_output   = gr.Image(label="Spectrogramme + Double Jitter")
-            report_output  = gr.Textbox(label="Rapport d'expertise", lines=20)
-            metrics_output = gr.JSON(label="Métriques détaillées")
+            image_output = gr.Image(label="Spectrogramme")
+            report_output = gr.Textbox(label="Rapport d'expertise", lines=12)
+            metrics_output = gr.JSON(label="Métriques")
 
-    run_btn.click(
-        fn=shield.analyser_expert,
-        inputs=audio_input,
-        outputs=[image_output, report_output, metrics_output]
-    )
+    run_btn.click(fn=shield.analyser_expert, inputs=audio_input, outputs=[image_output, report_output, metrics_output])
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)          
+    demo.launch(server_name="0.0.0.0", server_port=7860)