feat: update local demo for AURIS AI music detection with enhanced dashboard and model comparison

local_demo.py

@@ -1,7 +1,6 @@
 """
 AURIS Local Demo — AI Music Detection
-Gradio arayüzü ile eğitilmiş modeli doğrudan test et.
-Backend'e gerek yok, model local'de çalışır.
+Tüm eğitilmiş modelleri test edebileceğin local Gradio arayüzü.
 
 Çalıştır:
     python local_demo.py
@@ -16,13 +15,15 @@ from pathlib import Path
 import gradio as gr
 import numpy as np
 
-# ── Model yükleme ──────────────────────────────────────────────────
+# ── Paths ───────────────────────────────────────────────────────
 
 MODELS_DIR = Path(__file__).parent / "models"
 FIGURES_DIR = Path(__file__).parent.parent / "docs" / "academic" / "figures"
 
+# ── Load artifacts ──────────────────────────────────────────────
+
 with open(MODELS_DIR / "auris_classifier_v1.pkl", "rb") as f:
-    model = pickle.load(f)
+    main_model = pickle.load(f)
 
 with open(MODELS_DIR / "feature_scaler_v1.pkl", "rb") as f:
     scaler = pickle.load(f)
@@ -36,15 +37,23 @@ with open(MODELS_DIR / "training_results.json", "r") as f:
 best_model_name = training_results.get("_best_model", "Gradient Boosting")
 n_features = training_results.get("_n_features", 47)
 importance = training_results.get("_feature_importance", {})
-top_features = sorted(importance.items(), key=lambda x: x[1], reverse=True)[:10]
+top_features = sorted(importance.items(), key=lambda x: x[1], reverse=True)[:15]
+
+# All model results sorted by AUC
+all_models = sorted(
+    ((k, v) for k, v in training_results.items()
+     if not k.startswith("_") and isinstance(v, dict)),
+    key=lambda x: -x[1].get("roc_auc", 0),
+)
 
+print(f"AURIS Local Demo")
 print(f"Model: {best_model_name} | Features: {n_features}")
-print(f"Figures: {FIGURES_DIR}")
+print(f"Total models: {len(all_models)}")
 
 
-# ── Feature extraction (simplified — same as training pipeline) ────
+# ── Feature extraction ──────────────────────────────────────────
 
-def extract_features_from_audio(audio_path: str) -> dict:
+def extract_features_from_audio(audio_path: str) -> tuple[dict, float]:
     """Extract 47 features from audio file using librosa."""
     import librosa
     from scipy import stats as sp_stats
@@ -105,9 +114,8 @@ def extract_features_from_audio(audio_path: str) -> dict:
     total_energy = harm_energy + perc_energy + 1e-10
     harmonic_ratio = harm_energy / total_energy
 
-    # Mel features
+    # Mel
     mel = librosa.feature.melspectrogram(y=y, sr=sr, hop_length=512)
-    mel_db = librosa.power_to_db(mel)
     mel_flatness = float(np.mean(librosa.feature.spectral_flatness(S=mel)))
 
     # Onset
@@ -128,7 +136,6 @@ def extract_features_from_audio(audio_path: str) -> dict:
     else:
         pitch_std_cents = 0.0
 
-    # Heuristic scores (same sigmoid as training)
     def _sigmoid(x, center=0.5, steepness=6.0):
         return 1.0 / (1.0 + np.exp(-steepness * (x - center)))
 
@@ -136,7 +143,6 @@ def extract_features_from_audio(audio_path: str) -> dict:
     temporal_patterns = float(_sigmoid(1.0 - tempo_cv, 0.6, 5) if tempo_cv > 0 else 0.5)
     harmonic_structure = float(_sigmoid(harmonic_ratio, 0.5, 4))
 
-    # Build feature dict matching feature_columns_v1.json order
     feats = {
         "rms_energy": rms_mean,
         "rms_std": rms_std,
@@ -186,280 +192,359 @@ def extract_features_from_audio(audio_path: str) -> dict:
         "formant_consistency_score": 0.0,
         "breath_pattern_score": float(_sigmoid(rms_dynamic_range, 0.3, 5)),
     }
-
     return feats, duration_sec
 
 
 # ── Prediction ──────────────────────────────────────────────────
 
 def predict(audio_file):
-    """Run AURIS model on uploaded audio."""
+    """Run AURIS model on uploaded audio and return rich results."""
     if audio_file is None:
-        return (
-            "Dosya yükleyin / Upload a file",
-            None, None, None, None, None
-        )
+        return "Dosya yükleyin", None, None, ""
+
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
 
     t0 = time.time()
 
-    # Handle Gradio audio input (can be tuple or path)
     if isinstance(audio_file, tuple):
         audio_path = audio_file[0] if isinstance(audio_file[0], str) else None
         if audio_path is None:
-            return ("Geçersiz dosya", None, None, None, None, None)
+            return "Gecersiz dosya", None, None, ""
     else:
         audio_path = audio_file
 
     try:
         feats, duration = extract_features_from_audio(audio_path)
     except Exception as e:
-        return (f"Hata: {e}", None, None, None, None, None)
+        return f"Hata: {e}", None, None, ""
 
-    # Build feature vector in correct column order
     X = np.array([[feats.get(col, 0.0) for col in feature_cols]], dtype=np.float32)
     X = np.nan_to_num(X, nan=0.0, posinf=1.0, neginf=-1.0)
     X_scaled = scaler.transform(X)
 
     elapsed = time.time() - t0
-
-    # Get probability
-    prob = model.predict_proba(X_scaled)[0]
+    prob = main_model.predict_proba(X_scaled)[0]
     ai_prob = float(prob[1])
     human_prob = float(prob[0])
-    is_ai = ai_prob > 0.5
 
-    # Verdict
     if ai_prob > 0.8:
-        verdict = f"AI Üretimi Müzik Tespit Edildi — %{ai_prob*100:.1f} güven"
-        color = "#a64b3c"
+        verdict = f"AI Uretimi Muzik Tespit Edildi  |  %{ai_prob*100:.1f} guven"
     elif ai_prob > 0.5:
-        verdict = f"Muhtemelen AI Üretimi — %{ai_prob*100:.1f} güven"
-        color = "#c99347"
+        verdict = f"Muhtemelen AI Uretimi  |  %{ai_prob*100:.1f} guven"
     elif ai_prob > 0.3:
-        verdict = f"Muhtemelen İnsan Yapımı — %{human_prob*100:.1f} güven"
-        color = "#c99347"
+        verdict = f"Muhtemelen Insan Yapimi  |  %{human_prob*100:.1f} guven"
     else:
-        verdict = f"İnsan Yapımı Müzik — %{human_prob*100:.1f} güven"
-        color = "#7fb069"
+        verdict = f"Insan Yapimi Muzik  |  %{human_prob*100:.1f} guven"
 
-    # Feature scores display
     sr_pct = feats["spectral_regularity"] * 100
     tp_pct = feats["temporal_patterns"] * 100
     hs_pct = feats["harmonic_structure"] * 100
 
-    details_md = f"""
-## Sonuç / Result
-
-| | |
-|---|---|
-| **Karar** | {'AI Üretimi' if is_ai else 'İnsan Yapımı'} |
-| **AI Olasılığı** | %{ai_prob*100:.1f} |
-| **İnsan Olasılığı** | %{human_prob*100:.1f} |
-| **Model** | {best_model_name} |
-| **Süre** | {duration:.1f}s |
-| **İşlem Süresi** | {elapsed:.2f}s |
-
-## Ses Özellik Analizi
-
-| Özellik | Skor | Yorum |
-|---------|------|-------|
-| Spektral Düzenlilik | %{sr_pct:.0f} | {'AI benzeri düzenlilik' if sr_pct > 60 else 'Doğal varyasyon'} |
-| Zamansal Örüntüler | %{tp_pct:.0f} | {'Metronomik hassasiyet' if tp_pct > 60 else 'Doğal zamanlama'} |
-| Harmonik Yapı | %{hs_pct:.0f} | {'Tahmin edilebilir paternler' if hs_pct > 60 else 'Organik harmonik yapı'} |
-
-## En Önemli 10 Özellik (Bu Dosya İçin)
-
-| Özellik | Değer | Global Önem |
-|---------|-------|-------------|
-"""
-    for fname, imp in top_features:
-        val = feats.get(fname, 0.0)
-        details_md += f"| {fname} | {val:.4f} | {imp:.4f} |\n"
-
-    # Gauge plot
-    import matplotlib
-    matplotlib.use("Agg")
-    import matplotlib.pyplot as plt
-    import matplotlib.patches as mpatches
-
-    fig, ax = plt.subplots(figsize=(6, 3), subplot_kw={"projection": "polar"})
-    fig.patch.set_facecolor("#1a1207")
+    # ── Main dashboard plot (16:9) ──
+    fig = plt.figure(figsize=(16, 9), facecolor="#1a1207")
 
+    # ── Left: Gauge + verdict ──
+    ax_gauge = fig.add_axes([0.02, 0.45, 0.28, 0.50], projection="polar")
+    ax_gauge.set_facecolor("#1a1207")
     theta = np.linspace(np.pi, 0, 100)
     r = np.ones(100)
-    # Background arc
-    ax.plot(theta, r, color="#3d2817", linewidth=20, alpha=0.3)
-    # Score arc
-    score_end = int(ai_prob * 100)
-    if score_end > 0:
-        c = "#7fb069" if ai_prob < 0.4 else "#c99347" if ai_prob < 0.7 else "#a64b3c"
-        ax.plot(theta[:score_end], r[:score_end], color=c, linewidth=20)
-
-    # Needle
-    needle_angle = np.pi - ai_prob * np.pi
-    ax.plot([needle_angle, needle_angle], [0, 0.85], color="#faf6ed", linewidth=2)
-    ax.scatter([needle_angle], [0.85], color="#faf6ed", s=30, zorder=5)
-
-    ax.set_ylim(0, 1.2)
-    ax.set_yticklabels([])
-    ax.set_xticklabels([])
-    ax.spines["polar"].set_visible(False)
-    ax.grid(False)
-
-    ax.text(0, -0.3, f"%{ai_prob*100:.0f}", ha="center", va="center",
-            fontsize=28, fontweight="bold", color="#faf6ed",
-            transform=ax.transAxes)
-    ax.text(0, -0.45, "AI Olasılığı", ha="center", va="center",
-            fontsize=10, color="#c99347", transform=ax.transAxes)
-
-    plt.tight_layout()
-    gauge_path = str(Path(__file__).parent / "_gauge_temp.png")
-    plt.savefig(gauge_path, dpi=100, bbox_inches="tight",
-                facecolor="#1a1207", edgecolor="none")
-    plt.close()
-
-    # Feature bars plot
-    fig2, ax2 = plt.subplots(figsize=(6, 2.5))
-    fig2.patch.set_facecolor("#1a1207")
-    ax2.set_facecolor("#1a1207")
-
-    bars_data = [
-        ("Spektral Düzenlilik", sr_pct),
-        ("Zamansal Örüntüler", tp_pct),
-        ("Harmonik Yapı", hs_pct),
+    ax_gauge.plot(theta, r, color="#3d2817", linewidth=24, alpha=0.4)
+    score_end = max(1, int(ai_prob * 100))
+    c = "#7fb069" if ai_prob < 0.4 else "#c99347" if ai_prob < 0.7 else "#a64b3c"
+    ax_gauge.plot(theta[:score_end], r[:score_end], color=c, linewidth=24)
+    needle = np.pi - ai_prob * np.pi
+    ax_gauge.plot([needle, needle], [0, 0.82], color="#faf6ed", linewidth=2.5)
+    ax_gauge.scatter([needle], [0.82], color="#faf6ed", s=40, zorder=5)
+    ax_gauge.set_ylim(0, 1.2)
+    ax_gauge.set_yticklabels([])
+    ax_gauge.set_xticklabels([])
+    ax_gauge.spines["polar"].set_visible(False)
+    ax_gauge.grid(False)
+
+    fig.text(0.16, 0.42, f"%{ai_prob*100:.0f}", ha="center", va="center",
+             fontsize=42, fontweight="bold", color="#faf6ed")
+    fig.text(0.16, 0.36, "AI Olasiligi", ha="center", va="center",
+             fontsize=12, color="#c99347")
+
+    label = "AI URETIMI" if ai_prob > 0.5 else "INSAN YAPIMI"
+    label_color = "#a64b3c" if ai_prob > 0.5 else "#7fb069"
+    fig.text(0.16, 0.30, label, ha="center", va="center",
+             fontsize=16, fontweight="bold", color=label_color,
+             bbox=dict(boxstyle="round,pad=0.4", facecolor="#2a1f10",
+                       edgecolor=label_color, linewidth=2))
+
+    # ── Middle: Feature bars ──
+    ax_bars = fig.add_axes([0.35, 0.55, 0.28, 0.35])
+    ax_bars.set_facecolor("#2a1f10")
+    bars = [
+        ("Spektral Duzenlilik", sr_pct),
+        ("Zamansal Oruntuler", tp_pct),
+        ("Harmonik Yapi", hs_pct),
     ]
-    y_pos = np.arange(len(bars_data))
-    vals = [v for _, v in bars_data]
-    colors = ["#c99347" if v > 60 else "#7fb069" for v in vals]
-
-    ax2.barh(y_pos, vals, color=colors, edgecolor="#3d2817", height=0.6)
-    ax2.set_yticks(y_pos)
-    ax2.set_yticklabels([n for n, _ in bars_data], color="#faf6ed", fontsize=10)
-    ax2.set_xlim(0, 100)
-    ax2.set_xlabel("Skor (%)", color="#c99347")
-    ax2.tick_params(colors="#c99347")
-    ax2.spines["top"].set_visible(False)
-    ax2.spines["right"].set_visible(False)
-    ax2.spines["bottom"].set_color("#3d2817")
-    ax2.spines["left"].set_color("#3d2817")
-
+    y_pos = np.arange(len(bars))
+    vals = [v for _, v in bars]
+    colors_b = ["#c99347" if v > 60 else "#7fb069" if v < 40 else "#e7c77a" for v in vals]
+
+    ax_bars.barh(y_pos, vals, color=colors_b, edgecolor="#3d2817", height=0.55)
+    ax_bars.set_yticks(y_pos)
+    ax_bars.set_yticklabels([n for n, _ in bars], color="#faf6ed", fontsize=11)
+    ax_bars.set_xlim(0, 100)
+    ax_bars.set_xlabel("Skor (%)", color="#c99347", fontsize=10)
+    ax_bars.tick_params(colors="#c99347", labelsize=9)
+    for spine in ax_bars.spines.values():
+        spine.set_color("#3d2817")
     for i, v in enumerate(vals):
-        ax2.text(v + 1, i, f"%{v:.0f}", va="center", color="#faf6ed", fontsize=10)
-
-    plt.tight_layout()
-    bars_path = str(Path(__file__).parent / "_bars_temp.png")
-    plt.savefig(bars_path, dpi=100, bbox_inches="tight",
+        ax_bars.text(v + 1.5, i, f"%{v:.0f}", va="center", color="#faf6ed",
+                     fontsize=11, fontweight="bold")
+    ax_bars.set_title("Ses Ozellik Analizi", color="#c99347", fontsize=13,
+                      fontweight="bold", pad=8)
+
+    # ── Right: Top feature importance ──
+    ax_imp = fig.add_axes([0.70, 0.35, 0.27, 0.58])
+    ax_imp.set_facecolor("#2a1f10")
+    top10 = top_features[:10]
+    imp_names = [n for n, _ in top10]
+    imp_vals = [v * 100 for _, v in top10]
+    imp_colors = plt.cm.copper(np.linspace(0.3, 0.85, len(imp_names)))
+
+    ax_imp.barh(np.arange(len(imp_names)), imp_vals, color=imp_colors,
+                edgecolor="#3d2817", height=0.6)
+    ax_imp.set_yticks(np.arange(len(imp_names)))
+    ax_imp.set_yticklabels(imp_names, color="#faf6ed", fontsize=8)
+    ax_imp.invert_yaxis()
+    ax_imp.set_xlabel("Onem (%)", color="#c99347", fontsize=9)
+    ax_imp.tick_params(colors="#c99347", labelsize=8)
+    for spine in ax_imp.spines.values():
+        spine.set_color("#3d2817")
+    ax_imp.set_title("En Onemli Ozellikler", color="#c99347", fontsize=12,
+                      fontweight="bold", pad=8)
+
+    # ── Bottom: Info strip ──
+    info_text = (
+        f"Model: {best_model_name}  |  Sure: {duration:.1f}s  |  "
+        f"Islem: {elapsed:.2f}s  |  Ozellik: {n_features}  |  "
+        f"Tempo: {feats['tempo_bpm']:.0f} BPM  |  "
+        f"RMS: {feats['rms_energy']:.4f}"
+    )
+    fig.text(0.50, 0.06, info_text, ha="center", va="center",
+             fontsize=10, color="#c99347",
+             bbox=dict(boxstyle="round,pad=0.6", facecolor="#2a1f10",
+                       edgecolor="#3d2817", linewidth=1))
+
+    # ── Title ──
+    fig.text(0.50, 0.97, "AURIS — AI Music Detection System",
+             ha="center", va="top", fontsize=20, fontweight="bold",
+             color="#c99347")
+    fig.text(0.50, 0.93,
+             f"{best_model_name} | AUC={training_results.get(best_model_name, {}).get('roc_auc', 0):.4f}",
+             ha="center", va="top", fontsize=11, color="#faf6ed", alpha=0.7)
+
+    # ── Bottom left: Mini model comparison ──
+    ax_models = fig.add_axes([0.04, 0.12, 0.58, 0.22])
+    ax_models.set_facecolor("#2a1f10")
+    model_names = [n for n, _ in all_models]
+    model_aucs = [d.get("roc_auc", 0) for _, d in all_models]
+    model_types = []
+    for _, d in all_models:
+        if d.get("type") == "deep_learning":
+            model_types.append("#a64b3c")
+        else:
+            model_types.append("#c99347")
+
+    x_pos = np.arange(len(model_names))
+    ax_models.bar(x_pos, model_aucs, color=model_types, edgecolor="#3d2817",
+                  width=0.7)
+    ax_models.set_xticks(x_pos)
+    ax_models.set_xticklabels(model_names, rotation=30, ha="right",
+                               color="#faf6ed", fontsize=7)
+    ax_models.set_ylabel("ROC-AUC", color="#c99347", fontsize=9)
+    ax_models.set_ylim(0.80, 0.97)
+    ax_models.tick_params(colors="#c99347", labelsize=8)
+    for spine in ax_models.spines.values():
+        spine.set_color("#3d2817")
+    ax_models.set_title("Tum Modeller  (sari=ML, kirmizi=DL)", color="#c99347",
+                         fontsize=10, fontweight="bold", pad=6)
+    for i, v in enumerate(model_aucs):
+        ax_models.text(i, v + 0.002, f"{v:.3f}", ha="center", va="bottom",
+                       color="#faf6ed", fontsize=6)
+
+    dashboard_path = str(Path(__file__).parent / "_dashboard_temp.png")
+    plt.savefig(dashboard_path, dpi=120, bbox_inches="tight",
                 facecolor="#1a1207", edgecolor="none")
     plt.close()
 
-    return verdict, gauge_path, bars_path, details_md
+    # ── Details markdown ──
+    details_md = f"""
+## Detayli Sonuclar
+
+| Metrik | Deger |
+|--------|-------|
+| AI Olasiligi | %{ai_prob*100:.2f} |
+| Insan Olasiligi | %{human_prob*100:.2f} |
+| Model | {best_model_name} |
+| Audio Suresi | {duration:.1f}s |
+| Islem Suresi | {elapsed:.2f}s |
+| Tempo | {feats['tempo_bpm']:.1f} BPM |
+| RMS Energy | {feats['rms_energy']:.6f} |
+| Spectral Centroid | {feats['spectral_centroid_mean']:.1f} Hz |
+| Spectral Flatness | {feats['spectral_flatness_mean']:.6f} |
+| Harmonic Ratio | {feats['harmonic_ratio']:.4f} |
+| Zero Crossing Rate | {feats['zero_crossing_rate']:.6f} |
+| Beat Count | {feats['beat_count']:.0f} |
+
+## Tum {n_features} Ozellik Degerleri
+
+| Ozellik | Deger | Global Onem |
+|---------|-------|-------------|
+"""
+    for col in feature_cols:
+        val = feats.get(col, 0.0)
+        imp_val = importance.get(col, 0.0)
+        bar = "█" * int(imp_val * 200)
+        details_md += f"| {col} | {val:.6f} | {imp_val:.4f} {bar} |\n"
+
+    return verdict, dashboard_path, None, details_md
 
 
 # ── Figures gallery ─────────────────────────────────────────────
 
 def get_figure_paths():
-    """Get all academic figure paths."""
     if FIGURES_DIR.exists():
         return sorted(str(p) for p in FIGURES_DIR.glob("*.png"))
     return []
 
 
-# ── Gradio UI ───────────────────────────────────────────────────
+# ── Model comparison table ──────────────────────────────────────
 
-AURIS_CSS = """
-.gradio-container {
-    background: linear-gradient(135deg, #1a1207 0%, #2a1f10 50%, #1a1207 100%) !important;
-    font-family: 'Segoe UI', sans-serif;
-}
-.dark { background: #1a1207 !important; }
-h1, h2, h3 { color: #c99347 !important; }
-p, span, label { color: #faf6ed !important; }
-.gr-button-primary {
-    background: linear-gradient(135deg, #c99347, #e7c77a) !important;
-    color: #1a1207 !important;
-    border: none !important;
-    font-weight: bold !important;
-}
-footer { display: none !important; }
-"""
+ALL_MODELS_MD = """## Tum Egitilmis Model Sonuclari
 
-HEADER_MD = """
-# AURIS — AI Music Detection System
+> **En iyi model**: {best} | **Veri**: {n_samples} ornek | **Ozellik**: {n_feat} | **CV**: 5-fold stratified
 
-**Yapay Zeka Müzik Tespit Platformu**
+### Makine Ogrenmesi (ML) Modelleri
 
-Model: **{model}** | Özellikler: **{n_feat}** | Veri: **{n_samples}** örnek | AUC: **{auc}**
+| Model | Accuracy | Precision | Recall | F1 Score | ROC-AUC | Egitim Suresi |
+|-------|----------|-----------|--------|----------|---------|---------------|
 """.format(
-    model=best_model_name,
-    n_feat=n_features,
+    best=best_model_name,
     n_samples=training_results.get("_n_samples", "?"),
-    auc=training_results.get(best_model_name, {}).get("roc_auc", "?"),
+    n_feat=n_features,
 )
 
-ALL_MODELS_MD = "## Tüm Model Sonuçları\n\n| Model | Accuracy | F1 | ROC-AUC | Süre |\n|-------|----------|-----|---------|------|\n"
-for name, data in sorted(
-    ((k, v) for k, v in training_results.items()
-     if not k.startswith("_") and isinstance(v, dict)),
-    key=lambda x: -x[1].get("roc_auc", 0),
-):
-    ALL_MODELS_MD += (
-        f"| {name} | {data.get('accuracy', 0):.4f} | "
-        f"{data.get('f1', 0):.4f} | {data.get('roc_auc', 0):.4f} | "
+DL_MODELS_MD = """
+### Derin Ogrenme (DL) Modelleri
+
+| Model | Accuracy | Precision | Recall | F1 Score | ROC-AUC | Egitim Suresi |
+|-------|----------|-----------|--------|----------|---------|---------------|
+"""
+
+for name, data in all_models:
+    row = (
+        f"| {'**' + name + '**' if name == best_model_name else name} | "
+        f"{data.get('accuracy', 0):.4f} | "
+        f"{data.get('precision', 0):.4f} | "
+        f"{data.get('recall', 0):.4f} | "
+        f"{data.get('f1', 0):.4f} | "
+        f"{data.get('roc_auc', 0):.4f} | "
         f"{data.get('train_time_sec', 0):.1f}s |\n"
     )
+    if data.get("type") == "deep_learning":
+        DL_MODELS_MD += row
+    else:
+        ALL_MODELS_MD += row
+
+ALL_MODELS_MD += DL_MODELS_MD
+
+ALL_MODELS_MD += f"""
+### Ozellik Onemi (En Iyi Model: {best_model_name})
+
+| Sira | Ozellik | Onem | |
+|------|---------|------|-|
+"""
+for i, (fname, imp) in enumerate(top_features, 1):
+    bar = "█" * int(imp * 300)
+    ALL_MODELS_MD += f"| {i} | {fname} | {imp:.4f} | {bar} |\n"
+
+ALL_MODELS_MD += f"""
+### Notlar
+- **Veri sizintisi duzeltildi**: `duration_sec` ve `sample_rate` ozelliklerden cikarildi (v2)
+- **Regularizasyon**: max_depth=4, subsample=0.75, min_samples_leaf=12
+- Tree ensemble modellerinde train AUC=1.0 yapisal bir ozelliktir (overfitting degil)
+- DL modelleri (Deep MLP, Residual MLP) regularize edilmis ML'yi geciyor
+"""
 
+# ── Gradio UI ───────────────────────────────────────────────────
 
-with gr.Blocks(css=AURIS_CSS, title="AURIS — AI Music Detection", theme=gr.themes.Base()) as demo:
+AURIS_CSS = """
+.gradio-container {
+    background: linear-gradient(135deg, #1a1207 0%, #2a1f10 50%, #1a1207 100%) !important;
+    max-width: 1400px !important;
+}
+h1, h2, h3 { color: #c99347 !important; }
+p, span, label, td, th { color: #faf6ed !important; }
+table { border-color: #3d2817 !important; }
+th { background: #2a1f10 !important; color: #c99347 !important; }
+footer { display: none !important; }
+"""
 
-    gr.Markdown(HEADER_MD)
+HEADER_HTML = f"""
+<div style="text-align:center; padding: 16px 0;">
+    <h1 style="color:#c99347; margin:0; font-size:2.2em;">AURIS</h1>
+    <p style="color:#faf6ed; opacity:0.8; margin:4px 0;">
+        AI Music Detection System — Yapay Zeka Muzik Tespit Platformu
+    </p>
+    <p style="color:#c99347; font-size:0.9em;">
+        {best_model_name} | {n_features} ozellik |
+        {training_results.get('_n_samples', '?')} ornek |
+        AUC: {training_results.get(best_model_name, {}).get('roc_auc', '?')}
+    </p>
+</div>
+"""
+
+with gr.Blocks(title="AURIS — AI Music Detection") as demo:
+
+    gr.HTML(HEADER_HTML)
 
     with gr.Tabs():
-        # ── Tab 1: Analysis ──
-        with gr.Tab("Analiz / Analysis"):
+        with gr.Tab("Analiz"):
             with gr.Row():
                 with gr.Column(scale=1):
                     audio_input = gr.Audio(
-                        label="Audio Dosyası Yükle",
+                        label="Audio Dosyasi Yukle (.mp3, .wav, .flac)",
                         type="filepath",
                     )
                     analyze_btn = gr.Button(
-                        "Analiz Et / Analyze",
+                        "Analiz Et",
                         variant="primary",
                         size="lg",
                     )
-
-                with gr.Column(scale=1):
                     verdict_text = gr.Textbox(
-                        label="Sonuç / Verdict",
+                        label="Sonuc",
                         interactive=False,
                         lines=2,
                     )
-                    gauge_img = gr.Image(
-                        label="AI Olasılığı",
-                        type="filepath",
-                        height=200,
-                    )
-                    bars_img = gr.Image(
-                        label="Özellik Skorları",
+
+                with gr.Column(scale=2):
+                    dashboard_img = gr.Image(
+                        label="AURIS Dashboard",
                         type="filepath",
-                        height=180,
+                        height=500,
                     )
 
-            details_output = gr.Markdown(label="Detaylar")
+            details_output = gr.Markdown()
 
             analyze_btn.click(
                 fn=predict,
                 inputs=[audio_input],
-                outputs=[verdict_text, gauge_img, bars_img, details_output],
+                outputs=[verdict_text, dashboard_img, gr.State(), details_output],
             )
 
-        # ── Tab 2: Model Comparison ──
-        with gr.Tab("Model Karşılaştırması"):
+        with gr.Tab("Model Karsilastirmasi"):
             gr.Markdown(ALL_MODELS_MD)
 
-        # ── Tab 3: Academic Figures ──
-        with gr.Tab("Akademik Görseller"):
-            gr.Markdown("## Eğitim ve Değerlendirme Görselleri")
+        with gr.Tab("Akademik Gorseller"):
+            gr.Markdown("## Egitim ve Degerlendirme Gorselleri")
             figure_paths = get_figure_paths()
             if figure_paths:
                 gr.Gallery(
@@ -469,20 +554,21 @@ with gr.Blocks(css=AURIS_CSS, title="AURIS — AI Music Detection", theme=gr.the
                     height="auto",
                     object_fit="contain",
                 )
-            else:
-                gr.Markdown("*Görseller bulunamadı.*")
-
-    gr.Markdown(
-        "---\n"
-        "*AURIS v1 — Düzce Üniversitesi Bilgisayar Mühendisliği Bitirme Projesi*\n\n"
-        "*Hasan Arthur Altuntaş — 2026*"
-    )
 
+    gr.HTML("""
+    <div style="text-align:center; padding:12px; opacity:0.6;">
+        <p style="color:#c99347; font-size:0.85em;">
+            AURIS v1 — Duzce Universitesi Bilgisayar Muhendisligi Bitirme Projesi<br>
+            Hasan Arthur Altuntas — 2026
+        </p>
+    </div>
+    """)
 
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7861,
+        server_port=7862,
         share=False,
         inbrowser=True,
+        css=AURIS_CSS,
     )