Create app.py

app.py

@@ -0,0 +1,536 @@
+import gradio as gr
+import numpy as np
+import librosa
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+from matplotlib.gridspec import GridSpec
+import io
+from PIL import Image
+import warnings
+warnings.filterwarnings('ignore')
+
+# ── colour palette ──────────────────────────────────────────────────────────
+BG        = "#0a0a0f"
+PANEL     = "#12121a"
+ACCENT    = "#00f5c4"
+ACCENT2   = "#7b61ff"
+DANGER    = "#ff4d6d"
+WARNING   = "#ffb347"
+TEXT      = "#e8e8f0"
+SUBTEXT   = "#6b6b8a"
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  FEATURE EXTRACTION
+# ═══════════════════════════════════════════════════════════════════════════
+
+def extract_features(audio_path):
+    """Extract comprehensive audio features for deepfake detection."""
+    y, sr = librosa.load(audio_path, sr=None, duration=30)
+
+    feats = {}
+
+    # --- spectral features ---
+    feats["spectral_centroid"]    = float(np.mean(librosa.feature.spectral_centroid(y=y, sr=sr)))
+    feats["spectral_bandwidth"]   = float(np.mean(librosa.feature.spectral_bandwidth(y=y, sr=sr)))
+    feats["spectral_rolloff"]     = float(np.mean(librosa.feature.spectral_rolloff(y=y, sr=sr)))
+    feats["spectral_flatness"]    = float(np.mean(librosa.feature.spectral_flatness(y=y)))
+    feats["zero_crossing_rate"]   = float(np.mean(librosa.feature.zero_crossing_rate(y)))
+
+    # --- MFCCs ---
+    mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
+    for i, m in enumerate(mfccs):
+        feats[f"mfcc_{i+1}_mean"] = float(np.mean(m))
+        feats[f"mfcc_{i+1}_std"]  = float(np.std(m))
+
+    # --- rhythm ---
+    tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
+    feats["tempo"] = float(tempo)
+
+    # --- energy / dynamics ---
+    rms = librosa.feature.rms(y=y)[0]
+    feats["rms_mean"]  = float(np.mean(rms))
+    feats["rms_std"]   = float(np.std(rms))
+    feats["rms_range"] = float(np.max(rms) - np.min(rms))
+
+    # --- pitch / harmonics ---
+    f0, _, _ = librosa.pyin(y, fmin=librosa.note_to_hz('C2'),
+                            fmax=librosa.note_to_hz('C7'))
+    f0_clean = f0[~np.isnan(f0)] if f0 is not None else np.array([])
+    feats["f0_mean"]   = float(np.mean(f0_clean))   if len(f0_clean) > 0 else 0.0
+    feats["f0_std"]    = float(np.std(f0_clean))    if len(f0_clean) > 0 else 0.0
+    feats["f0_voiced"] = float(len(f0_clean) / max(len(f0), 1)) if f0 is not None else 0.0
+
+    # --- harmonics / noise ratio proxy ---
+    harm, perc = librosa.effects.hpss(y)
+    feats["harmonic_ratio"] = float(np.mean(np.abs(harm)) / (np.mean(np.abs(perc)) + 1e-8))
+
+    # --- chroma ---
+    chroma = librosa.feature.chroma_stft(y=y, sr=sr)
+    feats["chroma_mean"] = float(np.mean(chroma))
+    feats["chroma_std"]  = float(np.std(chroma))
+
+    return feats, y, sr
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  HEURISTIC DETECTION ENGINE
+# ═══════════════════════════════════════════════════════════════════════════
+
+def compute_ai_probability(feats):
+    """
+    Rule-based heuristic that returns (overall_score, sub_scores_dict).
+    Score range: 0.0 (fully human) → 1.0 (fully AI).
+    """
+    scores = {}
+
+    # 1. Spectral flatness — AI tends to be more spectrally uniform
+    sf = feats["spectral_flatness"]
+    scores["Spectral Uniformity"] = min(sf * 18, 1.0)
+
+    # 2. F0 stability — AI pitch is often unnaturally steady
+    f0_std = feats["f0_std"]
+    voiced  = feats["f0_voiced"]
+    if voiced > 0.3:
+        stability = max(0, 1 - (f0_std / 35))
+    else:
+        stability = 0.4
+    scores["Pitch Stability"] = float(np.clip(stability, 0, 1))
+
+    # 3. Harmonic-to-noise ratio — AI voices are often too clean
+    hr = feats["harmonic_ratio"]
+    scores["Harmonic Perfection"] = float(np.clip((hr - 1.5) / 8, 0, 1))
+
+    # 4. Dynamic range — AI tends to have compressed dynamics
+    rms_range = feats["rms_range"]
+    rms_mean  = feats["rms_mean"]
+    dyn_norm  = rms_range / (rms_mean + 1e-8)
+    scores["Dynamics Compression"] = float(np.clip(1 - (dyn_norm / 3.5), 0, 1))
+
+    # 5. MFCC variance — AI speech has less natural MFCC fluctuation
+    mfcc_stds = [feats[f"mfcc_{i}_std"] for i in range(1, 14)]
+    avg_mfcc_std = np.mean(mfcc_stds)
+    scores["MFCC Naturalness"] = float(np.clip(1 - (avg_mfcc_std / 22), 0, 1))
+
+    # 6. Zero crossing regularity — AI shows less randomness
+    zcr = feats["zero_crossing_rate"]
+    scores["Waveform Regularity"] = float(np.clip((0.15 - zcr) / 0.12 + 0.3, 0, 1))
+
+    # 7. Spectral bandwidth — AI voices often occupy a narrower band
+    bw = feats["spectral_bandwidth"]
+    scores["Bandwidth Compression"] = float(np.clip(1 - (bw / 3200), 0, 1))
+
+    # weighted average
+    weights = {
+        "Spectral Uniformity":    0.18,
+        "Pitch Stability":        0.22,
+        "Harmonic Perfection":    0.15,
+        "Dynamics Compression":   0.15,
+        "MFCC Naturalness":       0.15,
+        "Waveform Regularity":    0.08,
+        "Bandwidth Compression":  0.07,
+    }
+    overall = sum(scores[k] * weights[k] for k in scores)
+    overall = float(np.clip(overall, 0.0, 1.0))
+
+    return overall, scores
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  VISUALISATION
+# ═══════════════════════════════════════════════════════════════════════════
+
+def style_fig(fig):
+    fig.patch.set_facecolor(BG)
+
+
+def plot_waveform(y, sr):
+    fig, ax = plt.subplots(figsize=(9, 2.2))
+    style_fig(fig)
+    ax.set_facecolor(PANEL)
+    t = np.linspace(0, len(y)/sr, len(y))
+    ax.fill_between(t, y, alpha=0.7, color=ACCENT)
+    ax.plot(t, y, color=ACCENT, lw=0.4, alpha=0.9)
+    ax.set_xlabel("Time (s)", color=SUBTEXT, fontsize=8)
+    ax.set_ylabel("Amplitude", color=SUBTEXT, fontsize=8)
+    ax.set_title("Waveform", color=TEXT, fontsize=10, fontweight='bold', pad=8)
+    ax.tick_params(colors=SUBTEXT, labelsize=7)
+    for sp in ax.spines.values(): sp.set_edgecolor(SUBTEXT); sp.set_alpha(0.3)
+    fig.tight_layout(pad=0.8)
+    return fig
+
+
+def plot_spectrogram(y, sr):
+    fig, ax = plt.subplots(figsize=(9, 2.8))
+    style_fig(fig)
+    ax.set_facecolor(PANEL)
+    D = librosa.amplitude_to_db(np.abs(librosa.stft(y)), ref=np.max)
+    img = librosa.display.specshow(D, sr=sr, x_axis='time', y_axis='hz',
+                                   ax=ax, cmap='inferno')
+    plt.colorbar(img, ax=ax, format='%+2.0f dB', label='dB').ax.yaxis.label.set_color(SUBTEXT)
+    ax.set_title("Spectrogram", color=TEXT, fontsize=10, fontweight='bold', pad=8)
+    ax.tick_params(colors=SUBTEXT, labelsize=7)
+    ax.set_xlabel("Time (s)", color=SUBTEXT, fontsize=8)
+    ax.set_ylabel("Frequency (Hz)", color=SUBTEXT, fontsize=8)
+    for sp in ax.spines.values(): sp.set_edgecolor(SUBTEXT); sp.set_alpha(0.3)
+    fig.tight_layout(pad=0.8)
+    return fig
+
+
+def plot_mfcc(y, sr):
+    fig, ax = plt.subplots(figsize=(9, 2.8))
+    style_fig(fig)
+    ax.set_facecolor(PANEL)
+    mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
+    img = librosa.display.specshow(mfccs, x_axis='time', ax=ax, cmap='coolwarm')
+    plt.colorbar(img, ax=ax).ax.yaxis.label.set_color(SUBTEXT)
+    ax.set_title("MFCC Heatmap", color=TEXT, fontsize=10, fontweight='bold', pad=8)
+    ax.tick_params(colors=SUBTEXT, labelsize=7)
+    ax.set_xlabel("Time (s)", color=SUBTEXT, fontsize=8)
+    ax.set_ylabel("MFCC Coefficient", color=SUBTEXT, fontsize=8)
+    for sp in ax.spines.values(): sp.set_edgecolor(SUBTEXT); sp.set_alpha(0.3)
+    fig.tight_layout(pad=0.8)
+    return fig
+
+
+def plot_radar(sub_scores):
+    labels = list(sub_scores.keys())
+    vals   = [sub_scores[k] for k in labels]
+    N      = len(labels)
+
+    angles = np.linspace(0, 2*np.pi, N, endpoint=False).tolist()
+    vals_c = vals + [vals[0]]
+    ang_c  = angles + [angles[0]]
+
+    fig, ax = plt.subplots(figsize=(5, 5), subplot_kw=dict(polar=True))
+    style_fig(fig)
+    ax.set_facecolor(PANEL)
+    ax.plot(ang_c, vals_c, color=ACCENT2, lw=2)
+    ax.fill(ang_c, vals_c, color=ACCENT2, alpha=0.25)
+    ax.set_xticks(angles)
+    ax.set_xticklabels(labels, size=7.5, color=TEXT)
+    ax.set_yticks([0.25, 0.5, 0.75, 1.0])
+    ax.set_yticklabels(["25%","50%","75%","100%"], size=6, color=SUBTEXT)
+    ax.set_ylim(0, 1)
+    ax.tick_params(colors=SUBTEXT)
+    ax.spines['polar'].set_color(SUBTEXT); ax.spines['polar'].set_alpha(0.3)
+    ax.set_title("AI Indicator Radar", color=TEXT, fontsize=10, fontweight='bold', pad=18)
+    ax.grid(color=SUBTEXT, alpha=0.2)
+    fig.tight_layout()
+    return fig
+
+
+def plot_bar(sub_scores):
+    labels = list(sub_scores.keys())
+    vals   = [v * 100 for v in sub_scores.values()]
+
+    fig, ax = plt.subplots(figsize=(7, 4))
+    style_fig(fig)
+    ax.set_facecolor(PANEL)
+
+    colors = [DANGER if v > 65 else WARNING if v > 40 else ACCENT for v in vals]
+    bars = ax.barh(labels, vals, color=colors, height=0.55, edgecolor='none')
+
+    for bar, val in zip(bars, vals):
+        ax.text(min(val + 1.5, 97), bar.get_y() + bar.get_height()/2,
+                f"{val:.0f}%", va='center', ha='left', color=TEXT, fontsize=8)
+
+    ax.set_xlim(0, 105)
+    ax.set_xlabel("AI Likelihood (%)", color=SUBTEXT, fontsize=8)
+    ax.set_title("Sub-Indicator Breakdown", color=TEXT, fontsize=10, fontweight='bold', pad=8)
+    ax.tick_params(colors=SUBTEXT, labelsize=8)
+    for sp in ax.spines.values(): sp.set_edgecolor(SUBTEXT); sp.set_alpha(0.3)
+
+    patches = [
+        mpatches.Patch(color=DANGER,  label='High AI signal (>65%)'),
+        mpatches.Patch(color=WARNING, label='Moderate (40–65%)'),
+        mpatches.Patch(color=ACCENT,  label='Low AI signal (<40%)'),
+    ]
+    ax.legend(handles=patches, loc='lower right', fontsize=7,
+              facecolor=PANEL, edgecolor=SUBTEXT, labelcolor=TEXT)
+    fig.tight_layout(pad=0.8)
+    return fig
+
+
+def plot_gauge(score):
+    """Semicircular gauge."""
+    fig, ax = plt.subplots(figsize=(5, 3), subplot_kw=dict(aspect='equal'))
+    style_fig(fig)
+    ax.set_facecolor(BG)
+    ax.axis('off')
+
+    # background arc
+    theta_bg = np.linspace(np.pi, 0, 200)
+    ax.plot(np.cos(theta_bg), np.sin(theta_bg), color=PANEL, lw=28, solid_capstyle='round')
+
+    # filled arc
+    end_angle = np.pi - score * np.pi
+    theta_fill = np.linspace(np.pi, end_angle, 200)
+    fill_color = DANGER if score > 0.65 else WARNING if score > 0.4 else ACCENT
+    ax.plot(np.cos(theta_fill), np.sin(theta_fill), color=fill_color, lw=28, solid_capstyle='round')
+
+    # needle
+    needle_angle = np.pi - score * np.pi
+    ax.annotate("", xy=(0.72*np.cos(needle_angle), 0.72*np.sin(needle_angle)),
+                xytext=(0, 0),
+                arrowprops=dict(arrowstyle='->', color=TEXT, lw=2.5))
+    ax.add_patch(plt.Circle((0, 0), 0.06, color=TEXT, zorder=5))
+
+    # labels
+    ax.text(0, 0.28, f"{score*100:.1f}%", ha='center', va='center',
+            color=fill_color, fontsize=26, fontweight='bold')
+    ax.text(0, 0.05, "AI Generated", ha='center', va='center', color=SUBTEXT, fontsize=9)
+    ax.text(-1.05, -0.12, "HUMAN", color=ACCENT, fontsize=8, fontweight='bold')
+    ax.text( 0.75, -0.12, "AI",    color=DANGER,  fontsize=8, fontweight='bold')
+
+    ax.set_xlim(-1.2, 1.2)
+    ax.set_ylim(-0.3, 1.15)
+    ax.set_title("Detection Gauge", color=TEXT, fontsize=10, fontweight='bold', pad=4)
+    fig.tight_layout()
+    return fig
+
+
+def fig_to_pil(fig):
+    buf = io.BytesIO()
+    fig.savefig(buf, format='png', dpi=130, bbox_inches='tight',
+                facecolor=fig.get_facecolor())
+    buf.seek(0)
+    img = Image.open(buf).copy()
+    plt.close(fig)
+    return img
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  VERDICT TEXT
+# ═══════════════════════════════════════════════════════════════════════════
+
+def verdict_text(score, sub_scores):
+    pct = score * 100
+    if pct >= 75:
+        label, emoji = "HIGHLY LIKELY AI GENERATED", "🔴"
+        desc = (f"This audio shows strong AI synthesis signatures across multiple "
+                f"dimensions. The model detected {pct:.1f}% AI likelihood — "
+                f"consistent with TTS or voice cloning technology.")
+    elif pct >= 50:
+        label, emoji = "LIKELY AI GENERATED", "🟠"
+        desc = (f"Several AI indicators are elevated. The audio has a {pct:.1f}% "
+                f"probability of being synthesised, though some human elements remain.")
+    elif pct >= 30:
+        label, emoji = "AMBIGUOUS / MIXED", "🟡"
+        desc = (f"The signal is mixed ({pct:.1f}%). This could be lightly processed "
+                f"human speech, or a very natural-sounding AI voice. Manual review advised.")
+    else:
+        label, emoji = "LIKELY HUMAN", "🟢"
+        desc = (f"Low AI likelihood detected ({pct:.1f}%). The audio shows natural "
+                f"variance and organic imperfections consistent with genuine human speech.")
+
+    top_indicator = max(sub_scores, key=sub_scores.get)
+    top_val       = sub_scores[top_indicator] * 100
+
+    detail = (
+        f"\n\n**Key Finding:** The strongest AI signal came from **{top_indicator}** "
+        f"({top_val:.1f}%), "
+        + ("indicating unusually stable, machine-like characteristics in that dimension."
+           if top_val > 60 else
+           "though it remains within ambiguous territory.")
+    )
+
+    lines = [f"## {emoji} {label}", "", desc + detail, "", "---", "",
+             "**Sub-Indicator Summary:**"]
+    for k, v in sub_scores.items():
+        bar_filled = int(v * 20)
+        bar = "█" * bar_filled + "░" * (20 - bar_filled)
+        lines.append(f"`{k:<26}` `{bar}` **{v*100:.1f}%**")
+
+    return "\n".join(lines)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  MAIN PIPELINE
+# ═══════════════════════════════════════════════════════════════════════════
+
+def analyse_audio(audio_path):
+    if audio_path is None:
+        return (None,) * 6 + ("⚠️ Please upload an audio file first.",)
+
+    try:
+        feats, y, sr = extract_features(audio_path)
+        score, sub   = compute_ai_probability(feats)
+
+        gauge     = fig_to_pil(plot_gauge(score))
+        radar     = fig_to_pil(plot_radar(sub))
+        bar       = fig_to_pil(plot_bar(sub))
+        wave      = fig_to_pil(plot_waveform(y, sr))
+        spec      = fig_to_pil(plot_spectrogram(y, sr))
+        mfcc_img  = fig_to_pil(plot_mfcc(y, sr))
+        verdict   = verdict_text(score, sub)
+
+        return gauge, radar, bar, wave, spec, mfcc_img, verdict
+
+    except Exception as e:
+        err = f"❌ Analysis failed: {str(e)}\n\nPlease ensure your file is a valid audio format (WAV, MP3, FLAC, OGG)."
+        return (None,) * 6 + (err,)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  GRADIO UI
+# ═══════════════════════════════════════════════════════════════════════════
+
+CSS = f"""
+@import url('https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@300;400;600;700&family=JetBrains+Mono:wght@400;700&display=swap');
+
+body, .gradio-container {{
+    background: {BG} !important;
+    font-family: 'Space Grotesk', sans-serif !important;
+    color: {TEXT} !important;
+}}
+
+/* Hero header */
+.hero {{
+    background: linear-gradient(135deg, #0d0d18 0%, #12122a 50%, #0a0f1a 100%);
+    border: 1px solid #1e1e3a;
+    border-radius: 20px;
+    padding: 40px 32px 32px;
+    margin-bottom: 24px;
+    position: relative;
+    overflow: hidden;
+    text-align: center;
+}}
+.hero::before {{
+    content: '';
+    position: absolute; inset: 0;
+    background: radial-gradient(ellipse at 30% 50%, rgba(0,245,196,0.07) 0%, transparent 60%),
+                radial-gradient(ellipse at 70% 50%, rgba(123,97,255,0.07) 0%, transparent 60%);
+    pointer-events: none;
+}}
+.hero h1 {{
+    font-size: 2.6rem; font-weight: 700; margin: 0 0 8px;
+    background: linear-gradient(90deg, {ACCENT}, {ACCENT2});
+    -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+    letter-spacing: -0.02em;
+}}
+.hero p {{ color: {SUBTEXT}; font-size: 1rem; margin: 0; }}
+.hero .badge {{
+    display: inline-block; background: rgba(0,245,196,0.1);
+    border: 1px solid rgba(0,245,196,0.3); border-radius: 20px;
+    padding: 4px 14px; font-size: 0.78rem; color: {ACCENT};
+    font-family: 'JetBrains Mono', monospace; margin-bottom: 16px;
+}}
+
+/* Upload zone */
+.upload-zone {{
+    border: 2px dashed rgba(0,245,196,0.3) !important;
+    border-radius: 16px !important;
+    background: rgba(18,18,26,0.8) !important;
+    transition: border-color 0.3s;
+}}
+.upload-zone:hover {{ border-color: {ACCENT} !important; }}
+
+/* Buttons */
+button.primary {{
+    background: linear-gradient(135deg, {ACCENT}, {ACCENT2}) !important;
+    color: #000 !important; font-weight: 700 !important;
+    border-radius: 12px !important; border: none !important;
+    font-size: 1rem !important; padding: 12px 32px !important;
+    transition: opacity 0.2s, transform 0.15s !important;
+}}
+button.primary:hover {{ opacity: 0.9 !important; transform: translateY(-1px) !important; }}
+
+/* Tabs */
+.tab-nav button {{ color: {SUBTEXT} !important; border-radius: 8px !important; }}
+.tab-nav button.selected {{ color: {ACCENT} !important; border-bottom: 2px solid {ACCENT} !important; }}
+
+/* Markdown */
+.prose {{ background: {PANEL}; border-radius: 12px; padding: 20px; border: 1px solid #1e1e3a; }}
+
+/* Section labels */
+.section-label {{
+    font-size: 0.72rem; letter-spacing: 0.12em; text-transform: uppercase;
+    color: {SUBTEXT}; font-family: 'JetBrains Mono', monospace; margin-bottom: 8px;
+}}
+"""
+
+HEADER_HTML = f"""
+<div class="hero">
+  <div class="badge">v2.1 · Acoustic Analysis Engine</div>
+  <h1>⚡ DeepFake Audio Detector</h1>
+  <p>Upload any audio clip — we'll expose AI synthesis fingerprints with multi-dimensional acoustic analysis</p>
+</div>
+"""
+
+HOW_IT_WORKS = """
+### 🔬 How the Detection Works
+
+This tool analyses **7 acoustic dimensions** known to differ between human and AI-synthesised speech:
+
+| Indicator | What it measures |
+|---|---|
+| **Spectral Uniformity** | AI voices have unnaturally flat spectral energy |
+| **Pitch Stability** | Human pitch wanders naturally; AI pitch is robotic-smooth |
+| **Harmonic Perfection** | AI voices are too clean — humans have breath noise & imperfections |
+| **Dynamics Compression** | Human speech has wide loudness variation; AI is compressed |
+| **MFCC Naturalness** | Mel-cepstral coefficients reveal synthesis artefacts |
+| **Waveform Regularity** | AI waveforms lack micro-jitter present in human recordings |
+| **Bandwidth Compression** | TTS systems often clip high-frequency content |
+
+> ⚠️ **Disclaimer:** This is a heuristic-based acoustic analyser — not a certified forensic tool. Low-quality recordings or heavy post-processing can affect results.
+"""
+
+def build_app():
+    with gr.Blocks(css=CSS, title="DeepFake Audio Detector") as demo:
+
+        gr.HTML(HEADER_HTML)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.HTML('<div class="section-label">📁 Upload Audio</div>')
+                audio_input = gr.Audio(
+                    label="Drop your audio file here",
+                    type="filepath",
+                    elem_classes=["upload-zone"]
+                )
+                analyse_btn = gr.Button("🔍 Analyse Audio", variant="primary", size="lg")
+                gr.HTML('<div style="height:12px"></div>')
+                gr.Markdown(HOW_IT_WORKS)
+
+            with gr.Column(scale=2):
+                gr.HTML('<div class="section-label">📊 Detection Results</div>')
+
+                with gr.Tabs():
+                    with gr.Tab("🎯 Verdict"):
+                        gauge_out  = gr.Image(label="Detection Gauge", show_label=False)
+                        verdict_md = gr.Markdown(elem_classes=["prose"])
+
+                    with gr.Tab("📡 Radar & Bars"):
+                        with gr.Row():
+                            radar_out = gr.Image(label="Radar Chart", show_label=False)
+                            bar_out   = gr.Image(label="Bar Chart",   show_label=False)
+
+                    with gr.Tab("🔊 Waveform"):
+                        wave_out = gr.Image(label="Waveform", show_label=False)
+
+                    with gr.Tab("🌈 Spectrogram"):
+                        spec_out = gr.Image(label="Spectrogram", show_label=False)
+
+                    with gr.Tab("🧬 MFCC"):
+                        mfcc_out = gr.Image(label="MFCC Heatmap", show_label=False)
+
+        analyse_btn.click(
+            fn=analyse_audio,
+            inputs=[audio_input],
+            outputs=[gauge_out, radar_out, bar_out, wave_out, spec_out, mfcc_out, verdict_md]
+        )
+
+        gr.HTML(f"""
+        <div style="text-align:center; padding:20px 0 8px; color:{SUBTEXT}; font-size:0.8rem; font-family:'JetBrains Mono',monospace;">
+            Built with Gradio · Librosa · Matplotlib &nbsp;|&nbsp; Heuristic acoustic analysis
+        </div>
+        """)
+
+    return demo
+
+
+if __name__ == "__main__":
+    app = build_app()
+    app.launch(share=False)